AG903ライブラリリファレンス
内容インデックスホーム
Body Source
本文ソース
1: 9: 10: 14: 15: 16: #include <stdio.h> 17: #include "pgp/pgpprm.h" 18: #include "register/AG903_pgpreg.h" 19: #include "AG903_common.h" 20: 21: #define AG903_PGPnDGC(ch) ((volatile AG903_PGP0DGC_Type *)(AG903_PGP0DGC_BASE + 0x800 * ch)) 22: #define AG903_PGPnDGCF(ch) ((volatile AG903_PGP0DGCF_Type *)(AG903_PGP0DGCF_BASE + 0x800 * ch)) 23: 24: 25: 32: void AG903_PgpPrmSetPGPnCMD(uint32_t id, uint32_t cmd) 33: { 34: uint32_t val; 35: 36: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 37: ASSERT(!(cmd & ~(0xF))); 38: 39: val = (cmd << AG903_PGPn_CMD_CMD_POS); 40: 41: AG903_PGPn(id)->CMD = val; 42: } 43: 44: 45: 52: void AG903_PgpPrmGetPGPnSTATE(uint32_t id, PGPPrmParamPGPnSTATE *state) 53: { 54: uint32_t val; 55: 56: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 57: ASSERT(state != NULL); 58: 59: val = AG903_PGPn(id)->STATE; 60: 61: state->blank = (val & AG903_PGPn_STATE_BLANK_MSK) >> AG903_PGPn_STATE_BLANK_POS; 62: state->vrmacc = (val & AG903_PGPn_STATE_VRMACC_MSK) >> AG903_PGPn_STATE_VRMACC_POS; 63: state->queue = (val & AG903_PGPn_STATE_QUEUE_MSK) >> AG903_PGPn_STATE_QUEUE_POS; 64: state->sst = (val & AG903_PGPn_STATE_SST_MSK) >> AG903_PGPn_STATE_SST_POS; 65: state->st = (val & AG903_PGPn_STATE_ST_MSK) >> AG903_PGPn_STATE_ST_POS; 66: } 67: 68: 69: 78: void AG903_PgpPrmSetPGPnINTCTRLI(uint32_t id, uint32_t field, uint32_t fcnt, uint32_t line) 79: { 80: uint32_t val; 81: 82: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 83: ASSERT(!(field & ~(0x3))); 84: ASSERT(!(fcnt & ~(0xF))); 85: ASSERT(!(line & ~(0x1FFF))); 86: 87: val = (field << AG903_PGPn_INTCTRLI_FIELD_POS) 88: | (fcnt << AG903_PGPn_INTCTRLI_FCNT_POS) 89: | (line << AG903_PGPn_INTCTRLI_LINE_POS); 90: 91: AG903_PGPn(id)->INTCTRLI = val; 92: } 93: 94: 95: 104: void AG903_PgpPrmGetPGPnINTCTRLI(uint32_t id, uint32_t *field, uint32_t *fcnt, uint32_t *line) 105: { 106: uint32_t val; 107: 108: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 109: ASSERT(field != NULL); 110: ASSERT(fcnt != NULL); 111: ASSERT(line != NULL); 112: 113: val = AG903_PGPn(id)->INTCTRLI; 114: 115: *field = (val & AG903_PGPn_INTCTRLI_FIELD_MSK) >> AG903_PGPn_INTCTRLI_FIELD_POS; 116: *fcnt = (val & AG903_PGPn_INTCTRLI_FCNT_MSK) >> AG903_PGPn_INTCTRLI_FCNT_POS; 117: *line = (val & AG903_PGPn_INTCTRLI_LINE_MSK) >> AG903_PGPn_INTCTRLI_LINE_POS; 118: } 119: 120: 121: 130: void AG903_PgpPrmSetPGPnINTCTRLO(uint32_t id, uint32_t field, uint32_t fcnt, uint32_t line) 131: { 132: uint32_t val; 133: 134: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 135: ASSERT(!(field & ~(0x3))); 136: ASSERT(!(fcnt & ~(0xF))); 137: ASSERT(!(line & ~(0xFFF))); 138: 139: val = (field << AG903_PGPn_INTCTRLO_FIELD_POS) 140: | (fcnt << AG903_PGPn_INTCTRLO_FCNT_POS) 141: | (line << AG903_PGPn_INTCTRLO_LINE_POS); 142: 143: AG903_PGPn(id)->INTCTRLO = val; 144: } 145: 146: 147: 156: void AG903_PgpPrmGetPGPnINTCTRLO(uint32_t id, uint32_t *field, uint32_t *fcnt, uint32_t *line) 157: { 158: uint32_t val; 159: 160: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 161: ASSERT(field != NULL); 162: ASSERT(fcnt != NULL); 163: ASSERT(line != NULL); 164: 165: val = AG903_PGPn(id)->INTCTRLO; 166: 167: *field = (val & AG903_PGPn_INTCTRLO_FIELD_MSK) >> AG903_PGPn_INTCTRLO_FIELD_POS; 168: *fcnt = (val & AG903_PGPn_INTCTRLO_FCNT_MSK) >> AG903_PGPn_INTCTRLO_FCNT_POS; 169: *line = (val & AG903_PGPn_INTCTRLO_LINE_MSK) >> AG903_PGPn_INTCTRLO_LINE_POS; 170: } 171: 172: 173: 180: void AG903_PgpPrmSetPGPnINTEN(uint32_t id, PGPPrmParamPGPnINTEN *inten) 181: { 182: uint32_t val; 183: 184: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 185: ASSERT(inten != NULL); 186: ASSERT(!(inten->nd & ~(0x1))); 187: ASSERT(!(inten->voicpl & ~(0x1))); 188: ASSERT(!(inten->vooflw & ~(0x1))); 189: ASSERT(!(inten->ifcofs & ~(0x1))); 190: ASSERT(!(inten->ifcofm & ~(0x1))); 191: ASSERT(!(inten->lblcrpt & ~(0x1))); 192: ASSERT(!(inten->lblcpl & ~(0x1))); 193: ASSERT(!(inten->hgmicpl & ~(0x1))); 194: ASSERT(!(inten->hgmcpl & ~(0x1))); 195: ASSERT(!(inten->vsynco & ~(0x1))); 196: ASSERT(!(inten->vlineo & ~(0x1))); 197: ASSERT(!(inten->vsynci & ~(0x1))); 198: ASSERT(!(inten->vlinei & ~(0x1))); 199: 200: val = (inten->nd << AG903_PGPn_INTEN_ND_POS) 201: | (inten->voicpl << AG903_PGPn_INTEN_VOICPL_POS) 202: | (inten->vooflw << AG903_PGPn_INTEN_VOOFLW_POS) 203: | (inten->ifcofs << AG903_PGPn_INTEN_IFCOFS_POS) 204: | (inten->ifcofm << AG903_PGPn_INTEN_IFCOFM_POS) 205: | (inten->lblcrpt << AG903_PGPn_INTEN_LBLCRPT_POS) 206: | (inten->lblcpl << AG903_PGPn_INTEN_LBLCPL_POS) 207: | (inten->hgmicpl << AG903_PGPn_INTEN_HGMICPL_POS) 208: | (inten->hgmcpl << AG903_PGPn_INTEN_HGMCPL_POS) 209: | (inten->vsynco << AG903_PGPn_INTEN_VSYNCO_POS) 210: | (inten->vlineo << AG903_PGPn_INTEN_VLINEO_POS) 211: | (inten->vsynci << AG903_PGPn_INTEN_VSYNCI_POS) 212: | (inten->vlinei << AG903_PGPn_INTEN_VLINEI_POS); 213: 214: AG903_PGPn(id)->INTEN = val; 215: } 216: 217: 218: 225: void AG903_PgpPrmGetPGPnINTEN(uint32_t id, PGPPrmParamPGPnINTEN *inten) 226: { 227: uint32_t val; 228: 229: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 230: ASSERT(inten != NULL); 231: 232: val = AG903_PGPn(id)->INTEN; 233: 234: inten->nd = (val & AG903_PGPn_INTEN_ND_MSK) >> AG903_PGPn_INTEN_ND_POS; 235: inten->voicpl = (val & AG903_PGPn_INTEN_VOICPL_MSK) >> AG903_PGPn_INTEN_VOICPL_POS; 236: inten->vooflw = (val & AG903_PGPn_INTEN_VOOFLW_MSK) >> AG903_PGPn_INTEN_VOOFLW_POS; 237: inten->ifcofs = (val & AG903_PGPn_INTEN_IFCOFS_MSK) >> AG903_PGPn_INTEN_IFCOFS_POS; 238: inten->ifcofm = (val & AG903_PGPn_INTEN_IFCOFM_MSK) >> AG903_PGPn_INTEN_IFCOFM_POS; 239: inten->lblcrpt = (val & AG903_PGPn_INTEN_LBLCRPT_MSK) >> AG903_PGPn_INTEN_LBLCRPT_POS; 240: inten->lblcpl = (val & AG903_PGPn_INTEN_LBLCPL_MSK) >> AG903_PGPn_INTEN_LBLCPL_POS; 241: inten->hgmicpl = (val & AG903_PGPn_INTEN_HGMICPL_MSK) >> AG903_PGPn_INTEN_HGMICPL_POS; 242: inten->hgmcpl = (val & AG903_PGPn_INTEN_HGMCPL_MSK) >> AG903_PGPn_INTEN_HGMCPL_POS; 243: inten->vsynco = (val & AG903_PGPn_INTEN_VSYNCO_MSK) >> AG903_PGPn_INTEN_VSYNCO_POS; 244: inten->vlineo = (val & AG903_PGPn_INTEN_VLINEO_MSK) >> AG903_PGPn_INTEN_VLINEO_POS; 245: inten->vsynci = (val & AG903_PGPn_INTEN_VSYNCI_MSK) >> AG903_PGPn_INTEN_VSYNCI_POS; 246: inten->vlinei = (val & AG903_PGPn_INTEN_VLINEI_MSK) >> AG903_PGPn_INTEN_VLINEI_POS; 247: } 248: 249: 250: 257: void AG903_PgpPrmGetPGPnINTSTAT(uint32_t id, PGPPrmParamPGPnINTSTAT *stat) 258: { 259: uint32_t val; 260: 261: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 262: ASSERT(stat != NULL); 263: 264: val = AG903_PGPn(id)->INTSTAT; 265: 266: stat->nd = (val & AG903_PGPn_INTSTAT_ND_MSK) >> AG903_PGPn_INTSTAT_ND_POS; 267: stat->voicpl = (val & AG903_PGPn_INTSTAT_VOICPL_MSK) >> AG903_PGPn_INTSTAT_VOICPL_POS; 268: stat->vooflw = (val & AG903_PGPn_INTSTAT_VOOFLW_MSK) >> AG903_PGPn_INTSTAT_VOOFLW_POS; 269: stat->ifcofs = (val & AG903_PGPn_INTSTAT_IFCOFS_MSK) >> AG903_PGPn_INTSTAT_IFCOFS_POS; 270: stat->ifcofm = (val & AG903_PGPn_INTSTAT_IFCOFM_MSK) >> AG903_PGPn_INTSTAT_IFCOFM_POS; 271: stat->lblcrpt = (val & AG903_PGPn_INTSTAT_LBLCRPT_MSK) >> AG903_PGPn_INTSTAT_LBLCRPT_POS; 272: stat->lblcpl = (val & AG903_PGPn_INTSTAT_LBLCPL_MSK) >> AG903_PGPn_INTSTAT_LBLCPL_POS; 273: stat->hgmicpl = (val & AG903_PGPn_INTSTAT_HGMICPL_MSK) >> AG903_PGPn_INTSTAT_HGMICPL_POS; 274: stat->hgmcpl = (val & AG903_PGPn_INTSTAT_HGMCPL_MSK) >> AG903_PGPn_INTSTAT_HGMCPL_POS; 275: stat->vsynco = (val & AG903_PGPn_INTSTAT_VSYNCO_MSK) >> AG903_PGPn_INTSTAT_VSYNCO_POS; 276: stat->vlineo = (val & AG903_PGPn_INTSTAT_VLINEO_MSK) >> AG903_PGPn_INTSTAT_VLINEO_POS; 277: stat->vsynci = (val & AG903_PGPn_INTSTAT_VSYNCI_MSK) >> AG903_PGPn_INTSTAT_VSYNCI_POS; 278: stat->vlinei = (val & AG903_PGPn_INTSTAT_VLINEI_MSK) >> AG903_PGPn_INTSTAT_VLINEI_POS; 279: } 280: 281: 282: 289: void AG903_PgpPrmSetPGPnINTCLR(uint32_t id, PGPPrmParamPGPnINTCLR *intclr) 290: { 291: uint32_t val; 292: 293: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 294: ASSERT(intclr != NULL); 295: ASSERT(!(intclr->nd & ~(0x1))); 296: ASSERT(!(intclr->voicpl & ~(0x1))); 297: ASSERT(!(intclr->vooflw & ~(0x1))); 298: ASSERT(!(intclr->ifcofs & ~(0x1))); 299: ASSERT(!(intclr->ifcofm & ~(0x1))); 300: ASSERT(!(intclr->lblcrpt & ~(0x1))); 301: ASSERT(!(intclr->lblcpl & ~(0x1))); 302: ASSERT(!(intclr->hgmicpl & ~(0x1))); 303: ASSERT(!(intclr->hgmcpl & ~(0x1))); 304: ASSERT(!(intclr->vsynco & ~(0x1))); 305: ASSERT(!(intclr->vlineo & ~(0x1))); 306: ASSERT(!(intclr->vsynci & ~(0x1))); 307: ASSERT(!(intclr->vlinei & ~(0x1))); 308: 309: val = (intclr->nd << AG903_PGPn_INTCLR_ND_POS) 310: | (intclr->voicpl << AG903_PGPn_INTCLR_VOICPL_POS) 311: | (intclr->vooflw << AG903_PGPn_INTCLR_VOOFLW_POS) 312: | (intclr->ifcofs << AG903_PGPn_INTCLR_IFCOFS_POS) 313: | (intclr->ifcofm << AG903_PGPn_INTCLR_IFCOFM_POS) 314: | (intclr->lblcrpt << AG903_PGPn_INTCLR_LBLCRPT_POS) 315: | (intclr->lblcpl << AG903_PGPn_INTCLR_LBLCPL_POS) 316: | (intclr->hgmicpl << AG903_PGPn_INTCLR_HGMICPL_POS) 317: | (intclr->hgmcpl << AG903_PGPn_INTCLR_HGMCPL_POS) 318: | (intclr->vsynco << AG903_PGPn_INTCLR_VSYNCO_POS) 319: | (intclr->vlineo << AG903_PGPn_INTCLR_VLINEO_POS) 320: | (intclr->vsynci << AG903_PGPn_INTCLR_VSYNCI_POS) 321: | (intclr->vlinei << AG903_PGPn_INTCLR_VLINEI_POS); 322: 323: AG903_PGPn(id)->INTCLR = val; 324: } 325: 326: 327: 336: void AG903_PgpPrmSetPGPnTRGCTRLI(uint32_t id, uint32_t field, uint32_t fcnt, uint32_t line) 337: { 338: uint32_t val; 339: 340: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 341: ASSERT(!(field & ~(0x3))); 342: ASSERT(!(fcnt & ~(0xF))); 343: ASSERT(!(line & ~(0x1FFF))); 344: 345: val = (field << AG903_PGPn_TRGCTRLI_FIELD_POS) 346: | (fcnt << AG903_PGPn_TRGCTRLI_FCNT_POS) 347: | (line << AG903_PGPn_TRGCTRLI_LINE_POS); 348: 349: AG903_PGPn(id)->TRGCTRLI = val; 350: } 351: 352: 353: 362: void AG903_PgpPrmGetPGPnTRGCTRLI(uint32_t id, uint32_t *field, uint32_t *fcnt, uint32_t *line) 363: { 364: uint32_t val; 365: 366: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 367: ASSERT(field != NULL); 368: ASSERT(fcnt != NULL); 369: ASSERT(line != NULL); 370: 371: val = AG903_PGPn(id)->TRGCTRLI; 372: 373: *field = (val & AG903_PGPn_TRGCTRLI_FIELD_MSK) >> AG903_PGPn_TRGCTRLI_FIELD_POS; 374: *fcnt = (val & AG903_PGPn_TRGCTRLI_FCNT_MSK) >> AG903_PGPn_TRGCTRLI_FCNT_POS; 375: *line = (val & AG903_PGPn_TRGCTRLI_LINE_MSK) >> AG903_PGPn_TRGCTRLI_LINE_POS; 376: } 377: 378: 379: 388: void AG903_PgpPrmSetPGPnTRGCTRLO(uint32_t id, uint32_t field, uint32_t fcnt, uint32_t line) 389: { 390: uint32_t val; 391: 392: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 393: ASSERT(!(field & ~(0x3))); 394: ASSERT(!(fcnt & ~(0xF))); 395: ASSERT(!(line & ~(0xFFF))); 396: 397: val = (field << AG903_PGPn_TRGCTRLO_FIELD_POS) 398: | (fcnt << AG903_PGPn_TRGCTRLO_FCNT_POS) 399: | (line << AG903_PGPn_TRGCTRLO_LINE_POS); 400: 401: AG903_PGPn(id)->TRGCTRLO = val; 402: } 403: 404: 405: 414: void AG903_PgpPrmGetPGPnTRGCTRLO(uint32_t id, uint32_t *field, uint32_t *fcnt, uint32_t *line) 415: { 416: uint32_t val; 417: 418: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 419: ASSERT(field != NULL); 420: ASSERT(fcnt != NULL); 421: ASSERT(line != NULL); 422: 423: val = AG903_PGPn(id)->TRGCTRLO; 424: 425: *field = (val & AG903_PGPn_TRGCTRLO_FIELD_MSK) >> AG903_PGPn_TRGCTRLO_FIELD_POS; 426: *fcnt = (val & AG903_PGPn_TRGCTRLO_FCNT_MSK) >> AG903_PGPn_TRGCTRLO_FCNT_POS; 427: *line = (val & AG903_PGPn_TRGCTRLO_LINE_MSK) >> AG903_PGPn_TRGCTRLO_LINE_POS; 428: } 429: 430: 431: 438: void AG903_PgpPrmSetPGPnTRGEN(uint32_t id, PGPPrmParamPGPnTRGEN *trgen) 439: { 440: uint32_t val; 441: 442: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 443: ASSERT(trgen != NULL); 444: ASSERT(!(trgen->vsynco & ~(0x1))); 445: ASSERT(!(trgen->vlineo & ~(0x1))); 446: ASSERT(!(trgen->vsynci & ~(0x1))); 447: ASSERT(!(trgen->vlinei & ~(0x1))); 448: 449: val = (trgen->vsynco << AG903_PGPn_TRGEN_VSYNCO_POS) 450: | (trgen->vlineo << AG903_PGPn_TRGEN_VLINEO_POS) 451: | (trgen->vsynci << AG903_PGPn_TRGEN_VSYNCI_POS) 452: | (trgen->vlinei << AG903_PGPn_TRGEN_VLINEI_POS); 453: 454: AG903_PGPn(id)->TRGEN = val; 455: } 456: 457: 458: 465: void AG903_PgpPrmGetPGPnTRGEN(uint32_t id, PGPPrmParamPGPnTRGEN *trgen) 466: { 467: uint32_t val; 468: 469: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 470: ASSERT(trgen != NULL); 471: 472: val = AG903_PGPn(id)->TRGEN; 473: 474: trgen->vsynco = (val & AG903_PGPn_TRGEN_VSYNCO_MSK) >> AG903_PGPn_TRGEN_VSYNCO_POS; 475: trgen->vlineo = (val & AG903_PGPn_TRGEN_VLINEO_MSK) >> AG903_PGPn_TRGEN_VLINEO_POS; 476: trgen->vsynci = (val & AG903_PGPn_TRGEN_VSYNCI_MSK) >> AG903_PGPn_TRGEN_VSYNCI_POS; 477: trgen->vlinei = (val & AG903_PGPn_TRGEN_VLINEI_MSK) >> AG903_PGPn_TRGEN_VLINEI_POS; 478: } 479: 480: 481: 488: void AG903_PgpPrmSetPGPnINCTRL(uint32_t id, PGPPrmParamPGPnINCTRL *inctrl) 489: { 490: uint32_t val; 491: 492: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 493: ASSERT(inctrl != NULL); 494: ASSERT(!(inctrl->hdly & ~(0x7))); 495: ASSERT(!(inctrl->md & ~(0x3))); 496: ASSERT(!(inctrl->tick & ~(0x1))); 497: ASSERT(!(inctrl->trg & ~(0x7))); 498: ASSERT(!(inctrl->sel & ~(0xF))); 499: ASSERT(!(inctrl->fmt & ~(0x7))); 500: 501: val = (inctrl->hdly << AG903_PGPn_INCTRL_HDLY_POS) 502: | (inctrl->md << AG903_PGPn_INCTRL_MD_POS) 503: | (inctrl->tick << AG903_PGPn_INCTRL_TICK_POS) 504: | (inctrl->trg << AG903_PGPn_INCTRL_TRG_POS) 505: | (inctrl->sel << AG903_PGPn_INCTRL_SEL_POS) 506: | (inctrl->fmt << AG903_PGPn_INCTRL_FMT_POS); 507: 508: AG903_PGPn(id)->INCTRL = val; 509: } 510: 511: 512: 519: void AG903_PgpPrmGetPGPnINCTRL(uint32_t id, PGPPrmParamPGPnINCTRL *inctrl) 520: { 521: uint32_t val; 522: 523: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 524: ASSERT(inctrl != NULL); 525: 526: val = AG903_PGPn(id)->INCTRL; 527: 528: inctrl->hdly = (val & AG903_PGPn_INCTRL_HDLY_MSK) >> AG903_PGPn_INCTRL_HDLY_POS; 529: inctrl->md = (val & AG903_PGPn_INCTRL_MD_MSK) >> AG903_PGPn_INCTRL_MD_POS; 530: inctrl->tick = (val & AG903_PGPn_INCTRL_TICK_MSK) >> AG903_PGPn_INCTRL_TICK_POS; 531: inctrl->trg = (val & AG903_PGPn_INCTRL_TRG_MSK) >> AG903_PGPn_INCTRL_TRG_POS; 532: inctrl->sel = (val & AG903_PGPn_INCTRL_SEL_MSK) >> AG903_PGPn_INCTRL_SEL_POS; 533: inctrl->fmt = (val & AG903_PGPn_INCTRL_FMT_MSK) >> AG903_PGPn_INCTRL_FMT_POS; 534: } 535: 536: 537: 544: void AG903_PgpPrmSetPGPnFUNCCTRL(uint32_t id, PGPPrmParamPGPnFUNCCTRL *funcctrl) 545: { 546: uint32_t val; 547: 548: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 549: ASSERT(funcctrl != NULL); 550: ASSERT(!(funcctrl->out & ~(0x1))); 551: ASSERT(!(funcctrl->ifcodr & ~(0x1))); 552: ASSERT(!(funcctrl->ifc & ~(0x1))); 553: ASSERT(!(funcctrl->thr & ~(0x1))); 554: ASSERT(!(funcctrl->dgc & ~(0x1))); 555: ASSERT(!(funcctrl->hsv1 & ~(0x1))); 556: ASSERT(!(funcctrl->spf & ~(0x1))); 557: ASSERT(!(funcctrl->scale & ~(0x1))); 558: ASSERT(!(funcctrl->csc1 & ~(0x1))); 559: ASSERT(!(funcctrl->nrf & ~(0x1))); 560: 561: val = (funcctrl->out << AG903_PGPn_FUNCCTRL_OUT_POS) 562: | (funcctrl->ifcodr << AG903_PGPn_FUNCCTRL_IFCODR_POS) 563: | (funcctrl->ifc << AG903_PGPn_FUNCCTRL_IFC_POS) 564: | (funcctrl->thr << AG903_PGPn_FUNCCTRL_THR_POS) 565: | (funcctrl->dgc << AG903_PGPn_FUNCCTRL_DGC_POS) 566: | (funcctrl->hsv1 << AG903_PGPn_FUNCCTRL_HSV1_POS) 567: | (funcctrl->spf << AG903_PGPn_FUNCCTRL_SPF_POS) 568: | (funcctrl->scale << AG903_PGPn_FUNCCTRL_SCALE_POS) 569: | (funcctrl->csc1 << AG903_PGPn_FUNCCTRL_CSC1_POS) 570: | (funcctrl->nrf << AG903_PGPn_FUNCCTRL_NRF_POS); 571: 572: AG903_PGPn(id)->FUNCCTRL = val; 573: } 574: 575: 576: 583: void AG903_PgpPrmGetPGPnFUNCCTRL(uint32_t id, PGPPrmParamPGPnFUNCCTRL *funcctrl) 584: { 585: uint32_t val; 586: 587: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 588: ASSERT(funcctrl != NULL); 589: 590: val = AG903_PGPn(id)->FUNCCTRL; 591: 592: funcctrl->out = (val & AG903_PGPn_FUNCCTRL_OUT_MSK) >> AG903_PGPn_FUNCCTRL_OUT_POS; 593: funcctrl->ifcodr = (val & AG903_PGPn_FUNCCTRL_IFCODR_MSK) >> AG903_PGPn_FUNCCTRL_IFCODR_POS; 594: funcctrl->ifc = (val & AG903_PGPn_FUNCCTRL_IFC_MSK) >> AG903_PGPn_FUNCCTRL_IFC_POS; 595: funcctrl->thr = (val & AG903_PGPn_FUNCCTRL_THR_MSK) >> AG903_PGPn_FUNCCTRL_THR_POS; 596: funcctrl->dgc = (val & AG903_PGPn_FUNCCTRL_DGC_MSK) >> AG903_PGPn_FUNCCTRL_DGC_POS; 597: funcctrl->hsv1 = (val & AG903_PGPn_FUNCCTRL_HSV1_MSK) >> AG903_PGPn_FUNCCTRL_HSV1_POS; 598: funcctrl->spf = (val & AG903_PGPn_FUNCCTRL_SPF_MSK) >> AG903_PGPn_FUNCCTRL_SPF_POS; 599: funcctrl->scale = (val & AG903_PGPn_FUNCCTRL_SCALE_MSK) >> AG903_PGPn_FUNCCTRL_SCALE_POS; 600: funcctrl->csc1 = (val & AG903_PGPn_FUNCCTRL_CSC1_MSK) >> AG903_PGPn_FUNCCTRL_CSC1_POS; 601: funcctrl->nrf = (val & AG903_PGPn_FUNCCTRL_NRF_MSK) >> AG903_PGPn_FUNCCTRL_NRF_POS; 602: } 603: 604: 605: 613: void AG903_PgpPrmSetPGPnSIZE(uint32_t id, uint32_t vsize, uint32_t hsize) 614: { 615: uint32_t val; 616: 617: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 618: ASSERT(!(vsize & ~(0xFFF))); 619: ASSERT(!(hsize & ~(0xFFF))); 620: 621: val = (vsize << AG903_PGPn_SIZE_VSIZE_POS) 622: | (hsize << AG903_PGPn_SIZE_HSIZE_POS); 623: 624: AG903_PGPn(id)->SIZE = val; 625: } 626: 627: 628: 636: void AG903_PgpPrmGetPGPnSIZE(uint32_t id, uint32_t *vsize, uint32_t *hsize) 637: { 638: uint32_t val; 639: 640: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 641: ASSERT(vsize != NULL); 642: ASSERT(hsize != NULL); 643: 644: val = AG903_PGPn(id)->SIZE; 645: 646: *vsize = (val & AG903_PGPn_SIZE_VSIZE_MSK) >> AG903_PGPn_SIZE_VSIZE_POS; 647: *hsize = (val & AG903_PGPn_SIZE_HSIZE_MSK) >> AG903_PGPn_SIZE_HSIZE_POS; 648: } 649: 650: 651: 658: void AG903_PgpPrmSetPGPnPOS(uint32_t id, PGPPrmParamPGPnPOS *pos) 659: { 660: uint32_t val; 661: 662: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 663: ASSERT(pos != NULL); 664: ASSERT(!(pos->epos & ~(0x1))); 665: ASSERT(!(pos->opos & ~(0x1))); 666: ASSERT(!(pos->scan & ~(0x1))); 667: ASSERT(!(pos->vpos & ~(0x1FFF))); 668: ASSERT(!(pos->hpos & ~(0x1FFF))); 669: 670: val = (pos->epos << AG903_PGPn_POS_EPOS_POS) 671: | (pos->opos << AG903_PGPn_POS_OPOS_POS) 672: | (pos->scan << AG903_PGPn_POS_SCAN_POS) 673: | (pos->vpos << AG903_PGPn_POS_VPOS_POS) 674: | (pos->hpos << AG903_PGPn_POS_HPOS_POS); 675: 676: AG903_PGPn(id)->POS = val; 677: } 678: 679: 680: 687: void AG903_PgpPrmGetPGPnPOS(uint32_t id, PGPPrmParamPGPnPOS *pos) 688: { 689: uint32_t val; 690: 691: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 692: ASSERT(pos != NULL); 693: 694: val = AG903_PGPn(id)->POS; 695: 696: pos->epos = (val & AG903_PGPn_POS_EPOS_MSK) >> AG903_PGPn_POS_EPOS_POS; 697: pos->opos = (val & AG903_PGPn_POS_OPOS_MSK) >> AG903_PGPn_POS_OPOS_POS; 698: pos->scan = (val & AG903_PGPn_POS_SCAN_MSK) >> AG903_PGPn_POS_SCAN_POS; 699: pos->vpos = (val & AG903_PGPn_POS_VPOS_MSK) >> AG903_PGPn_POS_VPOS_POS; 700: pos->hpos = (val & AG903_PGPn_POS_HPOS_MSK) >> AG903_PGPn_POS_HPOS_POS; 701: } 702: 703: 704: 711: void AG903_PgpPrmSetPGPnOUTCTRL0(uint32_t id, PGPPrmParamPGPnOUTCTRL0 *outctrl0) 712: { 713: uint32_t val; 714: 715: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 716: ASSERT(outctrl0 != NULL); 717: ASSERT(!(outctrl0->pad & ~(0xFF))); 718: ASSERT(!(outctrl0->limit & ~(0x1))); 719: ASSERT(!(outctrl0->fai & ~(0x1))); 720: ASSERT(!(outctrl0->dth & ~(0x1))); 721: ASSERT(!(outctrl0->bmu & ~(0x3))); 722: ASSERT(!(outctrl0->scan & ~(0x1))); 723: ASSERT(!(outctrl0->dim & ~(0x1))); 724: ASSERT(!(outctrl0->swapw & ~(0x1))); 725: ASSERT(!(outctrl0->swaph & ~(0x1))); 726: ASSERT(!(outctrl0->swap4 & ~(0x1))); 727: ASSERT(!(outctrl0->swap1 & ~(0x1))); 728: ASSERT(!(outctrl0->md & ~(0x7))); 729: ASSERT(!(outctrl0->fmt & ~(0xF))); 730: 731: val = (outctrl0->pad << AG903_PGPn_OUTCTRL0_PAD_POS) 732: | (outctrl0->limit << AG903_PGPn_OUTCTRL0_LIMIT_POS) 733: | (outctrl0->fai << AG903_PGPn_OUTCTRL0_FAI_POS) 734: | (outctrl0->dth << AG903_PGPn_OUTCTRL0_DTH_POS) 735: | (outctrl0->bmu << AG903_PGPn_OUTCTRL0_BMU_POS) 736: | (outctrl0->scan << AG903_PGPn_OUTCTRL0_SCAN_POS) 737: | (outctrl0->dim << AG903_PGPn_OUTCTRL0_DIM_POS) 738: | (outctrl0->swapw << AG903_PGPn_OUTCTRL0_SWAPW_POS) 739: | (outctrl0->swaph << AG903_PGPn_OUTCTRL0_SWAPH_POS) 740: | (outctrl0->swap4 << AG903_PGPn_OUTCTRL0_SWAP4_POS) 741: | (outctrl0->swap1 << AG903_PGPn_OUTCTRL0_SWAP1_POS) 742: | (outctrl0->md << AG903_PGPn_OUTCTRL0_MD_POS) 743: | (outctrl0->fmt << AG903_PGPn_OUTCTRL0_FMT_POS); 744: 745: AG903_PGPn(id)->OUTCTRL0 = val; 746: } 747: 748: 749: 756: void AG903_PgpPrmGetPGPnOUTCTRL0(uint32_t id, PGPPrmParamPGPnOUTCTRL0 *outctrl0) 757: { 758: uint32_t val; 759: 760: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 761: ASSERT(outctrl0 != NULL); 762: 763: val = AG903_PGPn(id)->OUTCTRL0; 764: 765: outctrl0->pad = (val & AG903_PGPn_OUTCTRL0_PAD_MSK) >> AG903_PGPn_OUTCTRL0_PAD_POS; 766: outctrl0->limit = (val & AG903_PGPn_OUTCTRL0_LIMIT_MSK) >> AG903_PGPn_OUTCTRL0_LIMIT_POS; 767: outctrl0->fai = (val & AG903_PGPn_OUTCTRL0_FAI_MSK) >> AG903_PGPn_OUTCTRL0_FAI_POS; 768: outctrl0->dth = (val & AG903_PGPn_OUTCTRL0_DTH_MSK) >> AG903_PGPn_OUTCTRL0_DTH_POS; 769: outctrl0->bmu = (val & AG903_PGPn_OUTCTRL0_BMU_MSK) >> AG903_PGPn_OUTCTRL0_BMU_POS; 770: outctrl0->scan = (val & AG903_PGPn_OUTCTRL0_SCAN_MSK) >> AG903_PGPn_OUTCTRL0_SCAN_POS; 771: outctrl0->dim = (val & AG903_PGPn_OUTCTRL0_DIM_MSK) >> AG903_PGPn_OUTCTRL0_DIM_POS; 772: outctrl0->swapw = (val & AG903_PGPn_OUTCTRL0_SWAPW_MSK) >> AG903_PGPn_OUTCTRL0_SWAPW_POS; 773: outctrl0->swaph = (val & AG903_PGPn_OUTCTRL0_SWAPH_MSK) >> AG903_PGPn_OUTCTRL0_SWAPH_POS; 774: outctrl0->swap4 = (val & AG903_PGPn_OUTCTRL0_SWAP4_MSK) >> AG903_PGPn_OUTCTRL0_SWAP4_POS; 775: outctrl0->swap1 = (val & AG903_PGPn_OUTCTRL0_SWAP1_MSK) >> AG903_PGPn_OUTCTRL0_SWAP1_POS; 776: outctrl0->md = (val & AG903_PGPn_OUTCTRL0_MD_MSK) >> AG903_PGPn_OUTCTRL0_MD_POS; 777: outctrl0->fmt = (val & AG903_PGPn_OUTCTRL0_FMT_MSK) >> AG903_PGPn_OUTCTRL0_FMT_POS; 778: } 779: 780: 781: 790: void AG903_PgpPrmSetPGPnOUTCTRL1(uint32_t id, uint32_t re, uint32_t ge, uint32_t be) 791: { 792: uint32_t val; 793: 794: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 795: ASSERT(!(re & ~(0x1))); 796: ASSERT(!(ge & ~(0x1))); 797: ASSERT(!(be & ~(0x1))); 798: 799: val = (re << AG903_PGPn_OUTCTRL1_RE_POS) 800: | (ge << AG903_PGPn_OUTCTRL1_GE_POS) 801: | (be << AG903_PGPn_OUTCTRL1_BE_POS); 802: 803: AG903_PGPn(id)->OUTCTRL1 = val; 804: } 805: 806: 807: 816: void AG903_PgpPrmGetPGPnOUTCTRL1(uint32_t id, uint32_t *re, uint32_t *ge, uint32_t *be) 817: { 818: uint32_t val; 819: 820: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 821: ASSERT(re != NULL); 822: ASSERT(ge != NULL); 823: ASSERT(be != NULL); 824: 825: val = AG903_PGPn(id)->OUTCTRL1; 826: 827: *re = (val & AG903_PGPn_OUTCTRL1_RE_MSK) >> AG903_PGPn_OUTCTRL1_RE_POS; 828: *ge = (val & AG903_PGPn_OUTCTRL1_GE_MSK) >> AG903_PGPn_OUTCTRL1_GE_POS; 829: *be = (val & AG903_PGPn_OUTCTRL1_BE_MSK) >> AG903_PGPn_OUTCTRL1_BE_POS; 830: } 831: 832: 833: 840: void AG903_PgpPrmSetPGPnOUTBASE(uint32_t id, uint32_t adr) 841: { 842: uint32_t val; 843: 844: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 845: ASSERT(!(adr & ~(0x1FFFFFFF))); 846: 847: val = (adr << AG903_PGPn_OUTBASE_ADR_POS); 848: 849: AG903_PGPn(id)->OUTBASE = val; 850: } 851: 852: 853: 860: void AG903_PgpPrmGetPGPnOUTBASE(uint32_t id, uint32_t *adr) 861: { 862: uint32_t val; 863: 864: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 865: ASSERT(adr != NULL); 866: 867: val = AG903_PGPn(id)->OUTBASE; 868: 869: *adr = (val & AG903_PGPn_OUTBASE_ADR_MSK) >> AG903_PGPn_OUTBASE_ADR_POS; 870: } 871: 872: 873: 880: void AG903_PgpPrmSetPGPnOUTHSIZE(uint32_t id, uint32_t hsize) 881: { 882: uint32_t val; 883: 884: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 885: ASSERT(!(hsize & ~(0x3FFF))); 886: 887: val = (hsize << AG903_PGPn_OUTHSIZE_HSIZE_POS); 888: 889: AG903_PGPn(id)->OUTHSIZE = val; 890: } 891: 892: 893: 900: void AG903_PgpPrmGetPGPnOUTHSIZE(uint32_t id, uint32_t *hsize) 901: { 902: uint32_t val; 903: 904: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 905: ASSERT(hsize != NULL); 906: 907: val = AG903_PGPn(id)->OUTHSIZE; 908: 909: *hsize = (val & AG903_PGPn_OUTHSIZE_HSIZE_MSK) >> AG903_PGPn_OUTHSIZE_HSIZE_POS; 910: } 911: 912: 913: 920: void AG903_PgpPrmGetPGPnFAIVAL0(uint32_t id, uint32_t *tmstamp) 921: { 922: uint32_t val; 923: 924: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 925: ASSERT(tmstamp != NULL); 926: 927: val = AG903_PGPn(id)->FAIVAL0; 928: 929: *tmstamp = (val & AG903_PGPn_FAIVAL0_TMSTMP_MSK) >> AG903_PGPn_FAIVAL0_TMSTMP_POS; 930: } 931: 932: 933: 942: void AG903_PgpPrmGetPGPnFAIVAL1(uint32_t id, uint32_t *field, uint32_t *port, uint32_t *fnum) 943: { 944: uint32_t val; 945: 946: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 947: ASSERT(field != NULL); 948: ASSERT(port != NULL); 949: ASSERT(fnum != NULL); 950: 951: val = AG903_PGPn(id)->FAIVAL1; 952: 953: *field = (val & AG903_PGPn_FAIVAL1_FIELD_MSK) >> AG903_PGPn_FAIVAL1_FIELD_POS; 954: *port = (val & AG903_PGPn_FAIVAL1_PORT_MSK) >> AG903_PGPn_FAIVAL1_PORT_POS; 955: *fnum = (val & AG903_PGPn_FAIVAL1_FNUM_MSK) >> AG903_PGPn_FAIVAL1_FNUM_POS; 956: } 957: 958: 959: 968: void AG903_PgpPrmSetPGPnIPCPRM(uint32_t id, uint32_t limit, uint32_t blky, uint32_t blkc) 969: { 970: uint32_t val; 971: 972: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 973: ASSERT(!(limit & ~(0x1))); 974: ASSERT(!(blky & ~(0xFF))); 975: ASSERT(!(blkc & ~(0xFF))); 976: 977: val = (limit << AG903_PGPn_IPCPRM_LIMIT_POS) 978: | (blky << AG903_PGPn_IPCPRM_BLKY_POS) 979: | (blkc << AG903_PGPn_IPCPRM_BLKC_POS); 980: 981: AG903_PGPn(id)->IPCPRM = val; 982: } 983: 984: 985: 994: void AG903_PgpPrmGetPGPnIPCPRM(uint32_t id, uint32_t *limit, uint32_t *blky, uint32_t *blkc) 995: { 996: uint32_t val; 997: 998: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 999: ASSERT(limit != NULL); 1000: ASSERT(blky != NULL); 1001: ASSERT(blkc != NULL); 1002: 1003: val = AG903_PGPn(id)->IPCPRM; 1004: 1005: *limit = (val & AG903_PGPn_IPCPRM_LIMIT_MSK) >> AG903_PGPn_IPCPRM_LIMIT_POS; 1006: *blky = (val & AG903_PGPn_IPCPRM_BLKY_MSK) >> AG903_PGPn_IPCPRM_BLKY_POS; 1007: *blkc = (val & AG903_PGPn_IPCPRM_BLKC_MSK) >> AG903_PGPn_IPCPRM_BLKC_POS; 1008: } 1009: 1010: 1011: 1019: void AG903_PgpPrmSetPGPnCSC1CTRL(uint32_t id, uint32_t limit, uint32_t sft) 1020: { 1021: uint32_t val; 1022: 1023: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 1024: ASSERT(!(limit & ~(0x1))); 1025: ASSERT(!(sft & ~(0xF))); 1026: 1027: val = (limit << AG903_PGPn_CSC1CTRL_LIMIT_POS) 1028: | (sft << AG903_PGPn_CSC1CTRL_SFT_POS); 1029: 1030: AG903_PGPn(id)->CSC1CTRL = val; 1031: } 1032: 1033: 1034: 1042: void AG903_PgpPrmGetPGPnCSC1CTRL(uint32_t id, uint32_t *limit, uint32_t *sft) 1043: { 1044: uint32_t val; 1045: 1046: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 1047: ASSERT(limit != NULL); 1048: ASSERT(sft != NULL); 1049: 1050: val = AG903_PGPn(id)->CSC1CTRL; 1051: 1052: *limit = (val & AG903_PGPn_CSC1CTRL_LIMIT_MSK) >> AG903_PGPn_CSC1CTRL_LIMIT_POS; 1053: *sft = (val & AG903_PGPn_CSC1CTRL_SFT_MSK) >> AG903_PGPn_CSC1CTRL_SFT_POS; 1054: } 1055: 1056: 1057: 1065: void AG903_PgpPrmSetPGPnCSC1PRM0(uint32_t id, uint32_t m12, uint32_t m11) 1066: { 1067: uint32_t val; 1068: 1069: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 1070: ASSERT(!(m12 & ~(0xFFF))); 1071: ASSERT(!(m11 & ~(0xFFF))); 1072: 1073: val = (m12 << AG903_PGPn_CSC1PRM0_M12_POS) 1074: | (m11 << AG903_PGPn_CSC1PRM0_M11_POS); 1075: 1076: AG903_PGPn(id)->CSC1PRM0 = val; 1077: } 1078: 1079: 1080: 1088: void AG903_PgpPrmGetPGPnCSC1PRM0(uint32_t id, uint32_t *m12, uint32_t *m11) 1089: { 1090: uint32_t val; 1091: 1092: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 1093: ASSERT(m12 != NULL); 1094: ASSERT(m11 != NULL); 1095: 1096: val = AG903_PGPn(id)->CSC1PRM0; 1097: 1098: *m12 = (val & AG903_PGPn_CSC1PRM0_M12_MSK) >> AG903_PGPn_CSC1PRM0_M12_POS; 1099: *m11 = (val & AG903_PGPn_CSC1PRM0_M11_MSK) >> AG903_PGPn_CSC1PRM0_M11_POS; 1100: } 1101: 1102: 1103: 1110: void AG903_PgpPrmSetPGPnCSC1PRM1(uint32_t id, uint32_t m13) 1111: { 1112: uint32_t val; 1113: 1114: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 1115: ASSERT(!(m13 & ~(0xFFF))); 1116: 1117: val = (m13 << AG903_PGPn_CSC1PRM1_M13_POS); 1118: 1119: AG903_PGPn(id)->CSC1PRM1 = val; 1120: } 1121: 1122: 1123: 1130: void AG903_PgpPrmGetPGPnCSC1PRM1(uint32_t id, uint32_t *m13) 1131: { 1132: uint32_t val; 1133: 1134: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 1135: ASSERT(m13 != NULL); 1136: 1137: val = AG903_PGPn(id)->CSC1PRM1; 1138: 1139: *m13 = (val & AG903_PGPn_CSC1PRM1_M13_MSK) >> AG903_PGPn_CSC1PRM1_M13_POS; 1140: } 1141: 1142: 1143: 1150: void AG903_PgpPrmSetPGPnCSC1PRM2(uint32_t id, uint32_t m14) 1151: { 1152: uint32_t val; 1153: 1154: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 1155: ASSERT(!(m14 & ~(0xFFFFF))); 1156: 1157: val = (m14 << AG903_PGPn_CSC1PRM2_M14_POS); 1158: 1159: AG903_PGPn(id)->CSC1PRM2 = val; 1160: } 1161: 1162: 1163: 1170: void AG903_PgpPrmGetPGPnCSC1PRM2(uint32_t id, uint32_t *m14) 1171: { 1172: uint32_t val; 1173: 1174: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 1175: ASSERT(m14 != NULL); 1176: 1177: val = AG903_PGPn(id)->CSC1PRM2; 1178: 1179: *m14 = (val & AG903_PGPn_CSC1PRM2_M14_MSK) >> AG903_PGPn_CSC1PRM2_M14_POS; 1180: } 1181: 1182: 1183: 1191: void AG903_PgpPrmSetPGPnCSC1PRM3(uint32_t id, uint32_t m22, uint32_t m21) 1192: { 1193: uint32_t val; 1194: 1195: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 1196: ASSERT(!(m22 & ~(0xFFF))); 1197: ASSERT(!(m21 & ~(0xFFF))); 1198: 1199: val = (m22 << AG903_PGPn_CSC1PRM3_M22_POS) 1200: | (m21 << AG903_PGPn_CSC1PRM3_M21_POS); 1201: 1202: AG903_PGPn(id)->CSC1PRM3 = val; 1203: } 1204: 1205: 1206: 1214: void AG903_PgpPrmGetPGPnCSC1PRM3(uint32_t id, uint32_t *m22, uint32_t *m21) 1215: { 1216: uint32_t val; 1217: 1218: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 1219: ASSERT(m22 != NULL); 1220: ASSERT(m21 != NULL); 1221: 1222: val = AG903_PGPn(id)->CSC1PRM3; 1223: 1224: *m22 = (val & AG903_PGPn_CSC1PRM3_M22_MSK) >> AG903_PGPn_CSC1PRM3_M22_POS; 1225: *m21 = (val & AG903_PGPn_CSC1PRM3_M21_MSK) >> AG903_PGPn_CSC1PRM3_M21_POS; 1226: } 1227: 1228: 1229: 1236: void AG903_PgpPrmSetPGPnCSC1PRM4(uint32_t id, uint32_t m23) 1237: { 1238: uint32_t val; 1239: 1240: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 1241: ASSERT(!(m23 & ~(0xFFF))); 1242: 1243: val = (m23 << AG903_PGPn_CSC1PRM4_M23_POS); 1244: 1245: AG903_PGPn(id)->CSC1PRM4 = val; 1246: } 1247: 1248: 1249: 1256: void AG903_PgpPrmGetPGPnCSC1PRM4(uint32_t id, uint32_t *m23) 1257: { 1258: uint32_t val; 1259: 1260: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 1261: ASSERT(m23 != NULL); 1262: 1263: val = AG903_PGPn(id)->CSC1PRM4; 1264: 1265: *m23 = (val & AG903_PGPn_CSC1PRM4_M23_MSK) >> AG903_PGPn_CSC1PRM4_M23_POS; 1266: } 1267: 1268: 1269: 1276: void AG903_PgpPrmSetPGPnCSC1PRM5(uint32_t id, uint32_t m24) 1277: { 1278: uint32_t val; 1279: 1280: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 1281: ASSERT(!(m24 & ~(0xFFFFF))); 1282: 1283: val = (m24 << AG903_PGPn_CSC1PRM5_M24_POS); 1284: 1285: AG903_PGPn(id)->CSC1PRM5 = val; 1286: } 1287: 1288: 1289: 1296: void AG903_PgpPrmGetPGPnCSC1PRM5(uint32_t id, uint32_t *m24) 1297: { 1298: uint32_t val; 1299: 1300: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 1301: ASSERT(m24 != NULL); 1302: 1303: val = AG903_PGPn(id)->CSC1PRM5; 1304: 1305: *m24 = (val & AG903_PGPn_CSC1PRM5_M24_MSK) >> AG903_PGPn_CSC1PRM5_M24_POS; 1306: } 1307: 1308: 1309: 1317: void AG903_PgpPrmSetPGPnCSC1PRM6(uint32_t id, uint32_t m32, uint32_t m31) 1318: { 1319: uint32_t val; 1320: 1321: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 1322: ASSERT(!(m32 & ~(0xFFF))); 1323: ASSERT(!(m31 & ~(0xFFF))); 1324: 1325: val = (m32 << AG903_PGPn_CSC1PRM6_M32_POS) 1326: | (m31 << AG903_PGPn_CSC1PRM6_M31_POS); 1327: 1328: AG903_PGPn(id)->CSC1PRM6 = val; 1329: } 1330: 1331: 1332: 1340: void AG903_PgpPrmGetPGPnCSC1PRM6(uint32_t id, uint32_t *m32, uint32_t *m31) 1341: { 1342: uint32_t val; 1343: 1344: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 1345: ASSERT(m32 != NULL); 1346: ASSERT(m31 != NULL); 1347: 1348: val = AG903_PGPn(id)->CSC1PRM6; 1349: 1350: *m32 = (val & AG903_PGPn_CSC1PRM6_M32_MSK) >> AG903_PGPn_CSC1PRM6_M32_POS; 1351: *m31 = (val & AG903_PGPn_CSC1PRM6_M31_MSK) >> AG903_PGPn_CSC1PRM6_M31_POS; 1352: } 1353: 1354: 1355: 1362: void AG903_PgpPrmSetPGPnCSC1PRM7(uint32_t id, uint32_t m33) 1363: { 1364: uint32_t val; 1365: 1366: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 1367: ASSERT(!(m33 & ~(0xFFF))); 1368: 1369: val = (m33 << AG903_PGPn_CSC1PRM7_M33_POS); 1370: 1371: AG903_PGPn(id)->CSC1PRM7 = val; 1372: } 1373: 1374: 1375: 1382: void AG903_PgpPrmGetPGPnCSC1PRM7(uint32_t id, uint32_t *m33) 1383: { 1384: uint32_t val; 1385: 1386: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 1387: ASSERT(m33 != NULL); 1388: 1389: val = AG903_PGPn(id)->CSC1PRM7; 1390: 1391: *m33 = (val & AG903_PGPn_CSC1PRM7_M33_MSK) >> AG903_PGPn_CSC1PRM7_M33_POS; 1392: } 1393: 1394: 1395: 1402: void AG903_PgpPrmSetPGPnCSC1PRM8(uint32_t id, uint32_t m34) 1403: { 1404: uint32_t val; 1405: 1406: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 1407: ASSERT(!(m34 & ~(0xFFFFF))); 1408: 1409: val = (m34 << AG903_PGPn_CSC1PRM8_M34_POS); 1410: 1411: AG903_PGPn(id)->CSC1PRM8 = val; 1412: } 1413: 1414: 1415: 1422: void AG903_PgpPrmGetPGPnCSC1PRM8(uint32_t id, uint32_t *m34) 1423: { 1424: uint32_t val; 1425: 1426: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 1427: ASSERT(m34 != NULL); 1428: 1429: val = AG903_PGPn(id)->CSC1PRM8; 1430: 1431: *m34 = (val & AG903_PGPn_CSC1PRM8_M34_MSK) >> AG903_PGPn_CSC1PRM8_M34_POS; 1432: } 1433: 1434: 1435: 1442: void AG903_PgpPrmSetPGPnSCCTRL(uint32_t id, PGPPrmParamPGPnSCCTRL *scctrl) 1443: { 1444: uint32_t val; 1445: 1446: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 1447: ASSERT(scctrl != NULL); 1448: ASSERT(!(scctrl->limit & ~(0x1))); 1449: ASSERT(!(scctrl->mtd & ~(0x1))); 1450: ASSERT(!(scctrl->nmrv & ~(0xF))); 1451: ASSERT(!(scctrl->dnmv & ~(0xF))); 1452: ASSERT(!(scctrl->nmrh & ~(0xF))); 1453: ASSERT(!(scctrl->dnmh & ~(0xF))); 1454: 1455: val = (scctrl->limit << AG903_PGPn_SCCTRL_LIMIT_POS) 1456: | (scctrl->mtd << AG903_PGPn_SCCTRL_MTD_POS) 1457: | (scctrl->nmrv << AG903_PGPn_SCCTRL_NMRV_POS) 1458: | (scctrl->dnmv << AG903_PGPn_SCCTRL_DNMV_POS) 1459: | (scctrl->nmrh << AG903_PGPn_SCCTRL_NMRH_POS) 1460: | (scctrl->dnmh << AG903_PGPn_SCCTRL_DNMH_POS); 1461: 1462: AG903_PGPn(id)->SCCTRL = val; 1463: } 1464: 1465: 1466: 1473: void AG903_PgpPrmGetPGPnSCCTRL(uint32_t id, PGPPrmParamPGPnSCCTRL *scctrl) 1474: { 1475: uint32_t val; 1476: 1477: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 1478: ASSERT(scctrl != NULL); 1479: 1480: val = AG903_PGPn(id)->SCCTRL; 1481: 1482: scctrl->limit = (val & AG903_PGPn_SCCTRL_LIMIT_MSK) >> AG903_PGPn_SCCTRL_LIMIT_POS; 1483: scctrl->mtd = (val & AG903_PGPn_SCCTRL_MTD_MSK) >> AG903_PGPn_SCCTRL_MTD_POS; 1484: scctrl->nmrv = (val & AG903_PGPn_SCCTRL_NMRV_MSK) >> AG903_PGPn_SCCTRL_NMRV_POS; 1485: scctrl->dnmv = (val & AG903_PGPn_SCCTRL_DNMV_MSK) >> AG903_PGPn_SCCTRL_DNMV_POS; 1486: scctrl->nmrh = (val & AG903_PGPn_SCCTRL_NMRH_MSK) >> AG903_PGPn_SCCTRL_NMRH_POS; 1487: scctrl->dnmh = (val & AG903_PGPn_SCCTRL_DNMH_MSK) >> AG903_PGPn_SCCTRL_DNMH_POS; 1488: } 1489: 1490: 1491: 1498: void AG903_PgpPrmSetPGPnSPFCTRL(uint32_t id, PGPPrmParamPGPnSPFCTRL *spfctrl) 1499: { 1500: uint32_t val; 1501: 1502: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 1503: ASSERT(spfctrl != NULL); 1504: ASSERT(!(spfctrl->sft & ~(0xF))); 1505: ASSERT(!(spfctrl->bc & ~(0x1))); 1506: ASSERT(!(spfctrl->r & ~(0xFF))); 1507: ASSERT(!(spfctrl->g & ~(0xFF))); 1508: ASSERT(!(spfctrl->b & ~(0xFF))); 1509: 1510: val = (spfctrl->sft << AG903_PGPn_SPFCTRL_SFT_POS) 1511: | (spfctrl->bc << AG903_PGPn_SPFCTRL_BC_POS) 1512: | (spfctrl->r << AG903_PGPn_SPFCTRL_R_POS) 1513: | (spfctrl->g << AG903_PGPn_SPFCTRL_G_POS) 1514: | (spfctrl->b << AG903_PGPn_SPFCTRL_B_POS); 1515: 1516: AG903_PGPn(id)->SPFCTRL = val; 1517: } 1518: 1519: 1520: 1527: void AG903_PgpPrmGetPGPnSPFCTRL(uint32_t id, PGPPrmParamPGPnSPFCTRL *spfctrl) 1528: { 1529: uint32_t val; 1530: 1531: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 1532: ASSERT(spfctrl != NULL); 1533: 1534: val = AG903_PGPn(id)->SPFCTRL; 1535: 1536: spfctrl->sft = (val & AG903_PGPn_SPFCTRL_SFT_MSK) >> AG903_PGPn_SPFCTRL_SFT_POS; 1537: spfctrl->bc = (val & AG903_PGPn_SPFCTRL_BC_MSK) >> AG903_PGPn_SPFCTRL_BC_POS; 1538: spfctrl->r = (val & AG903_PGPn_SPFCTRL_R_MSK) >> AG903_PGPn_SPFCTRL_R_POS; 1539: spfctrl->g = (val & AG903_PGPn_SPFCTRL_G_MSK) >> AG903_PGPn_SPFCTRL_G_POS; 1540: spfctrl->b = (val & AG903_PGPn_SPFCTRL_B_MSK) >> AG903_PGPn_SPFCTRL_B_POS; 1541: } 1542: 1543: 1544: 1553: void AG903_PgpPrmSetPGPnSPFPRM0(uint32_t id, uint32_t h1m, uint32_t h0m, uint32_t hmm) 1554: { 1555: uint32_t val; 1556: 1557: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 1558: ASSERT(!(h1m & ~(0xFF))); 1559: ASSERT(!(h0m & ~(0xFF))); 1560: ASSERT(!(hmm & ~(0xFF))); 1561: 1562: val = (h1m << AG903_PGPn_SPFPRM0_H1M_POS) 1563: | (h0m << AG903_PGPn_SPFPRM0_H0M_POS) 1564: | (hmm << AG903_PGPn_SPFPRM0_HMM_POS); 1565: 1566: AG903_PGPn(id)->SPFPRM0 = val; 1567: } 1568: 1569: 1570: 1579: void AG903_PgpPrmGetPGPnSPFPRM0(uint32_t id, uint32_t *h1m, uint32_t *h0m, uint32_t *hmm) 1580: { 1581: uint32_t val; 1582: 1583: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 1584: ASSERT(h1m != NULL); 1585: ASSERT(h0m != NULL); 1586: ASSERT(hmm != NULL); 1587: 1588: val = AG903_PGPn(id)->SPFPRM0; 1589: 1590: *h1m = (val & AG903_PGPn_SPFPRM0_H1M_MSK) >> AG903_PGPn_SPFPRM0_H1M_POS; 1591: *h0m = (val & AG903_PGPn_SPFPRM0_H0M_MSK) >> AG903_PGPn_SPFPRM0_H0M_POS; 1592: *hmm = (val & AG903_PGPn_SPFPRM0_HMM_MSK) >> AG903_PGPn_SPFPRM0_HMM_POS; 1593: } 1594: 1595: 1596: 1605: void AG903_PgpPrmSetPGPnSPFPRM1(uint32_t id, uint32_t h10, uint32_t h00, uint32_t hm0) 1606: { 1607: uint32_t val; 1608: 1609: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 1610: ASSERT(!(h10 & ~(0xFF))); 1611: ASSERT(!(h00 & ~(0xFF))); 1612: ASSERT(!(hm0 & ~(0xFF))); 1613: 1614: val = (h10 << AG903_PGPn_SPFPRM1_H10_POS) 1615: | (h00 << AG903_PGPn_SPFPRM1_H00_POS) 1616: | (hm0 << AG903_PGPn_SPFPRM1_HM0_POS); 1617: 1618: AG903_PGPn(id)->SPFPRM1 = val; 1619: } 1620: 1621: 1622: 1631: void AG903_PgpPrmGetPGPnSPFPRM1(uint32_t id, uint32_t *h10, uint32_t *h00, uint32_t *hm0) 1632: { 1633: uint32_t val; 1634: 1635: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 1636: ASSERT(h10 != NULL); 1637: ASSERT(h00 != NULL); 1638: ASSERT(hm0 != NULL); 1639: 1640: val = AG903_PGPn(id)->SPFPRM1; 1641: 1642: *h10 = (val & AG903_PGPn_SPFPRM1_H10_MSK) >> AG903_PGPn_SPFPRM1_H10_POS; 1643: *h00 = (val & AG903_PGPn_SPFPRM1_H00_MSK) >> AG903_PGPn_SPFPRM1_H00_POS; 1644: *hm0 = (val & AG903_PGPn_SPFPRM1_HM0_MSK) >> AG903_PGPn_SPFPRM1_HM0_POS; 1645: } 1646: 1647: 1648: 1657: void AG903_PgpPrmSetPGPnSPFPRM2(uint32_t id, uint32_t h11, uint32_t h01, uint32_t hm1) 1658: { 1659: uint32_t val; 1660: 1661: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 1662: ASSERT(!(h11 & ~(0xFF))); 1663: ASSERT(!(h01 & ~(0xFF))); 1664: ASSERT(!(hm1 & ~(0xFF))); 1665: 1666: val = (h11 << AG903_PGPn_SPFPRM2_H11_POS) 1667: | (h01 << AG903_PGPn_SPFPRM2_H01_POS) 1668: | (hm1 << AG903_PGPn_SPFPRM2_HM1_POS); 1669: 1670: AG903_PGPn(id)->SPFPRM2 = val; 1671: } 1672: 1673: 1674: 1683: void AG903_PgpPrmGetPGPnSPFPRM2(uint32_t id, uint32_t *h11, uint32_t *h01, uint32_t *hm1) 1684: { 1685: uint32_t val; 1686: 1687: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 1688: ASSERT(h11 != NULL); 1689: ASSERT(h01 != NULL); 1690: ASSERT(hm1 != NULL); 1691: 1692: val = AG903_PGPn(id)->SPFPRM2; 1693: 1694: *h11 = (val & AG903_PGPn_SPFPRM2_H11_MSK) >> AG903_PGPn_SPFPRM2_H11_POS; 1695: *h01 = (val & AG903_PGPn_SPFPRM2_H01_MSK) >> AG903_PGPn_SPFPRM2_H01_POS; 1696: *hm1 = (val & AG903_PGPn_SPFPRM2_HM1_MSK) >> AG903_PGPn_SPFPRM2_HM1_POS; 1697: } 1698: 1699: 1700: 1707: void AG903_PgpPrmSetPGPnSPFPRM3(uint32_t id, uint32_t ofs) 1708: { 1709: uint32_t val; 1710: 1711: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 1712: ASSERT(!(ofs & ~(0x1FF))); 1713: 1714: val = (ofs << AG903_PGPn_SPFPRM3_OFS_POS); 1715: 1716: AG903_PGPn(id)->SPFPRM3 = val; 1717: } 1718: 1719: 1720: 1727: void AG903_PgpPrmGetPGPnSPFPRM3(uint32_t id, uint32_t *ofs) 1728: { 1729: uint32_t val; 1730: 1731: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 1732: ASSERT(ofs != NULL); 1733: 1734: val = AG903_PGPn(id)->SPFPRM3; 1735: 1736: *ofs = (val & AG903_PGPn_SPFPRM3_OFS_MSK) >> AG903_PGPn_SPFPRM3_OFS_POS; 1737: } 1738: 1739: 1740: 1747: void AG903_PgpPrmSetPGPnHSV1CTRL(uint32_t id, uint32_t fmt) 1748: { 1749: uint32_t val; 1750: 1751: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 1752: ASSERT(!(fmt & ~(0x1))); 1753: 1754: val = (fmt << AG903_PGPn_HSV1CTRL_FMT_POS); 1755: 1756: AG903_PGPn(id)->HSV1CTRL = val; 1757: } 1758: 1759: 1760: 1767: void AG903_PgpPrmGetPGPnHSV1CTRL(uint32_t id, uint32_t *fmt) 1768: { 1769: uint32_t val; 1770: 1771: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 1772: ASSERT(fmt != NULL); 1773: 1774: val = AG903_PGPn(id)->HSV1CTRL; 1775: 1776: *fmt = (val & AG903_PGPn_HSV1CTRL_FMT_MSK) >> AG903_PGPn_HSV1CTRL_FMT_POS; 1777: } 1778: 1779: 1780: 1787: void AG903_PgpPrmGetPGPnDGCSTAT(uint32_t id, uint32_t *queue) 1788: { 1789: uint32_t val; 1790: 1791: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 1792: ASSERT(queue != NULL); 1793: 1794: val = AG903_PGPn(id)->DGCSTAT; 1795: 1796: *queue = (val & AG903_PGPn_DGCSTAT_QUEUE_MSK) >> AG903_PGPn_DGCSTAT_QUEUE_POS; 1797: } 1798: 1799: 1800: 1807: void AG903_PgpPrmSetPGPnHGMCMD(uint32_t id, uint32_t cmd) 1808: { 1809: uint32_t val; 1810: 1811: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 1812: ASSERT(!(cmd & ~(0x7))); 1813: 1814: val = (cmd << AG903_PGPn_HGMCMD_CMD_POS); 1815: 1816: AG903_PGPn(id)->HGMCMD = val; 1817: } 1818: 1819: 1820: 1827: void AG903_PgpPrmSetPGPnHGMCTRL(uint32_t id, PGPPrmParamPGPnHGMCTRL *hgmctrl) 1828: { 1829: uint32_t val; 1830: 1831: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 1832: ASSERT(hgmctrl != NULL); 1833: ASSERT(!(hgmctrl->inv & ~(0xF))); 1834: ASSERT(!(hgmctrl->bmu & ~(0x1))); 1835: ASSERT(!(hgmctrl->exc & ~(0x3))); 1836: ASSERT(!(hgmctrl->thr & ~(0xF))); 1837: ASSERT(!(hgmctrl->sft & ~(0xF))); 1838: ASSERT(!(hgmctrl->vinc & ~(0xF))); 1839: ASSERT(!(hgmctrl->hinc & ~(0xF))); 1840: 1841: val = (hgmctrl->inv << AG903_PGPn_HGMCTRL_INV_POS) 1842: | (hgmctrl->bmu << AG903_PGPn_HGMCTRL_BMU_POS) 1843: | (hgmctrl->exc << AG903_PGPn_HGMCTRL_EXC_POS) 1844: | (hgmctrl->thr << AG903_PGPn_HGMCTRL_THR_POS) 1845: | (hgmctrl->sft << AG903_PGPn_HGMCTRL_SFT_POS) 1846: | (hgmctrl->vinc << AG903_PGPn_HGMCTRL_VINC_POS) 1847: | (hgmctrl->hinc << AG903_PGPn_HGMCTRL_HINC_POS); 1848: 1849: AG903_PGPn(id)->HGMCTRL = val; 1850: } 1851: 1852: 1853: 1860: void AG903_PgpPrmGetPGPnHGMCTRL(uint32_t id, PGPPrmParamPGPnHGMCTRL *hgmctrl) 1861: { 1862: uint32_t val; 1863: 1864: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 1865: ASSERT(hgmctrl != NULL); 1866: 1867: val = AG903_PGPn(id)->HGMCTRL; 1868: 1869: hgmctrl->inv = (val & AG903_PGPn_HGMCTRL_INV_MSK) >> AG903_PGPn_HGMCTRL_INV_POS; 1870: hgmctrl->bmu = (val & AG903_PGPn_HGMCTRL_BMU_MSK) >> AG903_PGPn_HGMCTRL_BMU_POS; 1871: hgmctrl->exc = (val & AG903_PGPn_HGMCTRL_EXC_MSK) >> AG903_PGPn_HGMCTRL_EXC_POS; 1872: hgmctrl->thr = (val & AG903_PGPn_HGMCTRL_THR_MSK) >> AG903_PGPn_HGMCTRL_THR_POS; 1873: hgmctrl->sft = (val & AG903_PGPn_HGMCTRL_SFT_MSK) >> AG903_PGPn_HGMCTRL_SFT_POS; 1874: hgmctrl->vinc = (val & AG903_PGPn_HGMCTRL_VINC_MSK) >> AG903_PGPn_HGMCTRL_VINC_POS; 1875: hgmctrl->hinc = (val & AG903_PGPn_HGMCTRL_HINC_MSK) >> AG903_PGPn_HGMCTRL_HINC_POS; 1876: } 1877: 1878: 1879: 1887: void AG903_PgpPrmSetPGPnHGMSIZE(uint32_t id, uint32_t vsize, uint32_t hsize) 1888: { 1889: uint32_t val; 1890: 1891: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 1892: ASSERT(!(vsize & ~(0x3FF))); 1893: ASSERT(!(hsize & ~(0x3FF))); 1894: 1895: val = (vsize << AG903_PGPn_HGMSIZE_VSIZE_POS) 1896: | (hsize << AG903_PGPn_HGMSIZE_HSIZE_POS); 1897: 1898: AG903_PGPn(id)->HGMSIZE = val; 1899: } 1900: 1901: 1902: 1910: void AG903_PgpPrmGetPGPnHGMSIZE(uint32_t id, uint32_t *vsize, uint32_t *hsize) 1911: { 1912: uint32_t val; 1913: 1914: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 1915: ASSERT(vsize != NULL); 1916: ASSERT(hsize != NULL); 1917: 1918: val = AG903_PGPn(id)->HGMSIZE; 1919: 1920: *vsize = (val & AG903_PGPn_HGMSIZE_VSIZE_MSK) >> AG903_PGPn_HGMSIZE_VSIZE_POS; 1921: *hsize = (val & AG903_PGPn_HGMSIZE_HSIZE_MSK) >> AG903_PGPn_HGMSIZE_HSIZE_POS; 1922: } 1923: 1924: 1925: 1933: void AG903_PgpPrmSetPGPnHGMPOS(uint32_t id, uint32_t vpos, uint32_t hpos) 1934: { 1935: uint32_t val; 1936: 1937: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 1938: ASSERT(!(vpos & ~(0xFFF))); 1939: ASSERT(!(hpos & ~(0xFFF))); 1940: 1941: val = (vpos << AG903_PGPn_HGMPOS_VPOS_POS) 1942: | (hpos << AG903_PGPn_HGMPOS_HPOS_POS); 1943: 1944: AG903_PGPn(id)->HGMPOS = val; 1945: } 1946: 1947: 1948: 1956: void AG903_PgpPrmGetPGPnHGMPOS(uint32_t id, uint32_t *vpos, uint32_t *hpos) 1957: { 1958: uint32_t val; 1959: 1960: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 1961: ASSERT(vpos != NULL); 1962: ASSERT(hpos != NULL); 1963: 1964: val = AG903_PGPn(id)->HGMPOS; 1965: 1966: *vpos = (val & AG903_PGPn_HGMPOS_VPOS_MSK) >> AG903_PGPn_HGMPOS_VPOS_POS; 1967: *hpos = (val & AG903_PGPn_HGMPOS_HPOS_MSK) >> AG903_PGPn_HGMPOS_HPOS_POS; 1968: } 1969: 1970: 1971: 1978: void AG903_PgpPrmSetPGPnHGMDST(uint32_t id, uint32_t adr) 1979: { 1980: uint32_t val; 1981: 1982: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 1983: ASSERT(!(adr & ~(0x1FFFFFFF))); 1984: 1985: val = (adr << AG903_PGPn_HGMDST_ADR_POS); 1986: 1987: AG903_PGPn(id)->HGMDST = val; 1988: } 1989: 1990: 1991: 1998: void AG903_PgpPrmGetPGPnHGMDST(uint32_t id, uint32_t *adr) 1999: { 2000: uint32_t val; 2001: 2002: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 2003: ASSERT(adr != NULL); 2004: 2005: val = AG903_PGPn(id)->HGMDST; 2006: 2007: *adr = (val & AG903_PGPn_HGMDST_ADR_MSK) >> AG903_PGPn_HGMDST_ADR_POS; 2008: } 2009: 2010: 2011: 2020: void AG903_PgpPrmGetPGPnHGMMOD0(uint32_t id, uint32_t *bw, uint32_t *val, uint32_t *cnt) 2021: { 2022: uint32_t tmp; 2023: 2024: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 2025: ASSERT(bw != NULL); 2026: ASSERT(val != NULL); 2027: ASSERT(cnt != NULL); 2028: 2029: tmp = AG903_PGPn(id)->HGMMOD0; 2030: 2031: *bw = (tmp & AG903_PGPn_HGMMOD0_BW_MSK) >> AG903_PGPn_HGMMOD0_BW_POS; 2032: *val = (tmp & AG903_PGPn_HGMMOD0_VAL_MSK) >> AG903_PGPn_HGMMOD0_VAL_POS; 2033: *cnt = (tmp & AG903_PGPn_HGMMOD0_CNT_MSK) >> AG903_PGPn_HGMMOD0_CNT_POS; 2034: } 2035: 2036: 2037: 2045: void AG903_PgpPrmGetPGPnHGMRNG0(uint32_t id, uint32_t *maxval, uint32_t *minval) 2046: { 2047: uint32_t val; 2048: 2049: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 2050: ASSERT(maxval != NULL); 2051: ASSERT(minval != NULL); 2052: 2053: val = AG903_PGPn(id)->HGMRNG0; 2054: 2055: *maxval = (val & AG903_PGPn_HGMRNG0_MAXVAL_MSK) >> AG903_PGPn_HGMRNG0_MAXVAL_POS; 2056: *minval = (val & AG903_PGPn_HGMRNG0_MINVAL_MSK) >> AG903_PGPn_HGMRNG0_MINVAL_POS; 2057: } 2058: 2059: 2060: 2069: void AG903_PgpPrmGetPGPnHGMMOD1(uint32_t id, uint32_t *bw, uint32_t *val, uint32_t *cnt) 2070: { 2071: uint32_t dat; 2072: 2073: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 2074: ASSERT(bw != NULL); 2075: ASSERT(val != NULL); 2076: ASSERT(cnt != NULL); 2077: 2078: dat = AG903_PGPn(id)->HGMMOD1; 2079: 2080: *bw = (dat & AG903_PGPn_HGMMOD1_BW_MSK) >> AG903_PGPn_HGMMOD1_BW_POS; 2081: *val = (dat & AG903_PGPn_HGMMOD1_VAL_MSK) >> AG903_PGPn_HGMMOD1_VAL_POS; 2082: *cnt = (dat & AG903_PGPn_HGMMOD1_CNT_MSK) >> AG903_PGPn_HGMMOD1_CNT_POS; 2083: } 2084: 2085: 2086: 2094: void AG903_PgpPrmGetPGPnHGMRNG1(uint32_t id, uint32_t *maxval, uint32_t *minval) 2095: { 2096: uint32_t val; 2097: 2098: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 2099: ASSERT(maxval != NULL); 2100: ASSERT(minval != NULL); 2101: 2102: val = AG903_PGPn(id)->HGMRNG1; 2103: 2104: *maxval = (val & AG903_PGPn_HGMRNG1_MAXVAL_MSK) >> AG903_PGPn_HGMRNG1_MAXVAL_POS; 2105: *minval = (val & AG903_PGPn_HGMRNG1_MINVAL_MSK) >> AG903_PGPn_HGMRNG1_MINVAL_POS; 2106: } 2107: 2108: 2109: 2118: void AG903_PgpPrmGetPGPnHGMMOD2(uint32_t id, uint32_t *bw, uint32_t *val, uint32_t *cnt) 2119: { 2120: uint32_t dat; 2121: 2122: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 2123: ASSERT(bw != NULL); 2124: ASSERT(val != NULL); 2125: ASSERT(cnt != NULL); 2126: 2127: dat = AG903_PGPn(id)->HGMMOD2; 2128: 2129: *bw = (dat & AG903_PGPn_HGMMOD2_BW_MSK) >> AG903_PGPn_HGMMOD2_BW_POS; 2130: *val = (dat & AG903_PGPn_HGMMOD2_VAL_MSK) >> AG903_PGPn_HGMMOD2_VAL_POS; 2131: *cnt = (dat & AG903_PGPn_HGMMOD2_CNT_MSK) >> AG903_PGPn_HGMMOD2_CNT_POS; 2132: } 2133: 2134: 2135: 2143: void AG903_PgpPrmGetPGPnHGMRNG2(uint32_t id, uint32_t *maxval, uint32_t *minval) 2144: { 2145: uint32_t val; 2146: 2147: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 2148: ASSERT(maxval != NULL); 2149: ASSERT(minval != NULL); 2150: 2151: val = AG903_PGPn(id)->HGMRNG2; 2152: 2153: *maxval = (val & AG903_PGPn_HGMRNG2_MAXVAL_MSK) >> AG903_PGPn_HGMRNG2_MAXVAL_POS; 2154: *minval = (val & AG903_PGPn_HGMRNG2_MINVAL_MSK) >> AG903_PGPn_HGMRNG2_MINVAL_POS; 2155: } 2156: 2157: 2158: 2165: void AG903_PgpPrmGetPGPnHGMSTAT(uint32_t id, PGPPrmParamPGPnHGMSTAT *stat) 2166: { 2167: uint32_t val; 2168: 2169: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 2170: ASSERT(stat != NULL); 2171: 2172: val = AG903_PGPn(id)->HGMSTAT; 2173: 2174: stat->init = (val & AG903_PGPn_HGMSTAT_INIT_MSK) >> AG903_PGPn_HGMSTAT_INIT_POS; 2175: stat->vrmacc = (val & AG903_PGPn_HGMSTAT_VRMACC_MSK) >> AG903_PGPn_HGMSTAT_VRMACC_POS; 2176: stat->act = (val & AG903_PGPn_HGMSTAT_ACT_MSK) >> AG903_PGPn_HGMSTAT_ACT_POS; 2177: stat->queue = (val & AG903_PGPn_HGMSTAT_QUEUE_MSK) >> AG903_PGPn_HGMSTAT_QUEUE_POS; 2178: stat->cmd = (val & AG903_PGPn_HGMSTAT_CMD_MSK) >> AG903_PGPn_HGMSTAT_CMD_POS; 2179: } 2180: 2181: 2182: 2189: void AG903_PgpPrmSetPGPnTHRCTRL(uint32_t id, PGPPrmParamPGPnTHRCTRL *thrctrl) 2190: { 2191: uint32_t val; 2192: 2193: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 2194: ASSERT(thrctrl != NULL); 2195: ASSERT(!(thrctrl->limit & ~(0x1))); 2196: ASSERT(!(thrctrl->spf1 & ~(0x1))); 2197: ASSERT(!(thrctrl->msk & ~(0x1))); 2198: ASSERT(!(thrctrl->csc2 & ~(0x1))); 2199: ASSERT(!(thrctrl->hsv2 & ~(0x1))); 2200: ASSERT(!(thrctrl->thr8 & ~(0x1))); 2201: ASSERT(!(thrctrl->outsel & ~(0x3))); 2202: ASSERT(!(thrctrl->c8sel & ~(0x3))); 2203: 2204: val = (thrctrl->limit << AG903_PGPn_THRCTRL_LIMIT_POS) 2205: | (thrctrl->spf1 << AG903_PGPn_THRCTRL_SPF1_POS) 2206: | (thrctrl->msk << AG903_PGPn_THRCTRL_MSK_POS) 2207: | (thrctrl->csc2 << AG903_PGPn_THRCTRL_CSC2_POS) 2208: | (thrctrl->hsv2 << AG903_PGPn_THRCTRL_HSV2_POS) 2209: | (thrctrl->thr8 << AG903_PGPn_THRCTRL_THR8_POS) 2210: | (thrctrl->outsel << AG903_PGPn_THRCTRL_OUTSEL_POS) 2211: | (thrctrl->c8sel << AG903_PGPn_THRCTRL_C8SEL_POS); 2212: 2213: AG903_PGPn(id)->THRCTRL = val; 2214: } 2215: 2216: 2217: 2224: void AG903_PgpPrmGetPGPnTHRCTRL(uint32_t id, PGPPrmParamPGPnTHRCTRL *thrctrl) 2225: { 2226: uint32_t val; 2227: 2228: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 2229: ASSERT(thrctrl != NULL); 2230: 2231: val = AG903_PGPn(id)->THRCTRL; 2232: 2233: thrctrl->limit = (val & AG903_PGPn_THRCTRL_LIMIT_MSK) >> AG903_PGPn_THRCTRL_LIMIT_POS; 2234: thrctrl->spf1 = (val & AG903_PGPn_THRCTRL_SPF1_MSK) >> AG903_PGPn_THRCTRL_SPF1_POS; 2235: thrctrl->msk = (val & AG903_PGPn_THRCTRL_MSK_MSK) >> AG903_PGPn_THRCTRL_MSK_POS; 2236: thrctrl->csc2 = (val & AG903_PGPn_THRCTRL_CSC2_MSK) >> AG903_PGPn_THRCTRL_CSC2_POS; 2237: thrctrl->hsv2 = (val & AG903_PGPn_THRCTRL_HSV2_MSK) >> AG903_PGPn_THRCTRL_HSV2_POS; 2238: thrctrl->thr8 = (val & AG903_PGPn_THRCTRL_THR8_MSK) >> AG903_PGPn_THRCTRL_THR8_POS; 2239: thrctrl->outsel = (val & AG903_PGPn_THRCTRL_OUTSEL_MSK) >> AG903_PGPn_THRCTRL_OUTSEL_POS; 2240: thrctrl->c8sel = (val & AG903_PGPn_THRCTRL_C8SEL_MSK) >> AG903_PGPn_THRCTRL_C8SEL_POS; 2241: } 2242: 2243: 2244: 2251: void AG903_PgpPrmSetPGPnHSV2CTRL(uint32_t id, uint32_t fmt) 2252: { 2253: uint32_t val; 2254: 2255: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 2256: ASSERT(!(fmt & ~(0x1))); 2257: 2258: val = (fmt << AG903_PGPn_HSV2CTRL_FMT_POS); 2259: 2260: AG903_PGPn(id)->HSV2CTRL = val; 2261: } 2262: 2263: 2264: 2271: void AG903_PgpPrmGetPGPnHSV2CTRL(uint32_t id, uint32_t *fmt) 2272: { 2273: uint32_t val; 2274: 2275: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 2276: ASSERT(fmt != NULL); 2277: 2278: val = AG903_PGPn(id)->HSV2CTRL; 2279: 2280: *fmt = (val & AG903_PGPn_HSV2CTRL_FMT_MSK) >> AG903_PGPn_HSV2CTRL_FMT_POS; 2281: } 2282: 2283: 2284: 2292: void AG903_PgpPrmSetPGPnCSC2CTRL(uint32_t id, uint32_t limit, uint32_t sft) 2293: { 2294: uint32_t val; 2295: 2296: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 2297: ASSERT(!(limit & ~(0x1))); 2298: ASSERT(!(sft & ~(0xF))); 2299: 2300: val = (limit << AG903_PGPn_CSC2CTRL_LIMIT_POS) 2301: | (sft << AG903_PGPn_CSC2CTRL_SFT_POS); 2302: 2303: AG903_PGPn(id)->CSC2CTRL = val; 2304: } 2305: 2306: 2307: 2315: void AG903_PgpPrmGetPGPnCSC2CTRL(uint32_t id, uint32_t *limit, uint32_t *sft) 2316: { 2317: uint32_t val; 2318: 2319: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 2320: ASSERT(limit != NULL); 2321: ASSERT(sft != NULL); 2322: 2323: val = AG903_PGPn(id)->CSC2CTRL; 2324: 2325: *limit = (val & AG903_PGPn_CSC2CTRL_LIMIT_MSK) >> AG903_PGPn_CSC2CTRL_LIMIT_POS; 2326: *sft = (val & AG903_PGPn_CSC2CTRL_SFT_MSK) >> AG903_PGPn_CSC2CTRL_SFT_POS; 2327: } 2328: 2329: 2330: 2338: void AG903_PgpPrmSetPGPnCSC2PRM0(uint32_t id, uint32_t m12, uint32_t m11) 2339: { 2340: uint32_t val; 2341: 2342: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 2343: ASSERT(!(m12 & ~(0xFFF))); 2344: ASSERT(!(m11 & ~(0xFFF))); 2345: 2346: val = (m12 << AG903_PGPn_CSC2PRM0_M12_POS) 2347: | (m11 << AG903_PGPn_CSC2PRM0_M11_POS); 2348: 2349: AG903_PGPn(id)->CSC2PRM0 = val; 2350: } 2351: 2352: 2353: 2361: void AG903_PgpPrmGetPGPnCSC2PRM0(uint32_t id, uint32_t *m12, uint32_t *m11) 2362: { 2363: uint32_t val; 2364: 2365: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 2366: ASSERT(m12 != NULL); 2367: ASSERT(m11 != NULL); 2368: 2369: val = AG903_PGPn(id)->CSC2PRM0; 2370: 2371: *m12 = (val & AG903_PGPn_CSC2PRM0_M12_MSK) >> AG903_PGPn_CSC2PRM0_M12_POS; 2372: *m11 = (val & AG903_PGPn_CSC2PRM0_M11_MSK) >> AG903_PGPn_CSC2PRM0_M11_POS; 2373: } 2374: 2375: 2376: 2383: void AG903_PgpPrmSetPGPnCSC2PRM1(uint32_t id, uint32_t m13) 2384: { 2385: uint32_t val; 2386: 2387: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 2388: ASSERT(!(m13 & ~(0xFFF))); 2389: 2390: val = (m13 << AG903_PGPn_CSC2PRM1_M13_POS); 2391: 2392: AG903_PGPn(id)->CSC2PRM1 = val; 2393: } 2394: 2395: 2396: 2403: void AG903_PgpPrmGetPGPnCSC2PRM1(uint32_t id, uint32_t *m13) 2404: { 2405: uint32_t val; 2406: 2407: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 2408: ASSERT(m13 != NULL); 2409: 2410: val = AG903_PGPn(id)->CSC2PRM1; 2411: 2412: *m13 = (val & AG903_PGPn_CSC2PRM1_M13_MSK) >> AG903_PGPn_CSC2PRM1_M13_POS; 2413: } 2414: 2415: 2416: 2423: void AG903_PgpPrmSetPGPnCSC2PRM2(uint32_t id, uint32_t m14) 2424: { 2425: uint32_t val; 2426: 2427: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 2428: ASSERT(!(m14 & ~(0xFFFFF))); 2429: 2430: val = (m14 << AG903_PGPn_CSC2PRM2_M14_POS); 2431: 2432: AG903_PGPn(id)->CSC2PRM2 = val; 2433: } 2434: 2435: 2436: 2443: void AG903_PgpPrmGetPGPnCSC2PRM2(uint32_t id, uint32_t *m14) 2444: { 2445: uint32_t val; 2446: 2447: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 2448: ASSERT(m14 != NULL); 2449: 2450: val = AG903_PGPn(id)->CSC2PRM2; 2451: 2452: *m14 = (val & AG903_PGPn_CSC2PRM2_M14_MSK) >> AG903_PGPn_CSC2PRM2_M14_POS; 2453: } 2454: 2455: 2456: 2464: void AG903_PgpPrmSetPGPnCSC2PRM3(uint32_t id, uint32_t m22, uint32_t m21) 2465: { 2466: uint32_t val; 2467: 2468: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 2469: ASSERT(!(m22 & ~(0xFFF))); 2470: ASSERT(!(m21 & ~(0xFFF))); 2471: 2472: val = (m22 << AG903_PGPn_CSC2PRM3_M22_POS) 2473: | (m21 << AG903_PGPn_CSC2PRM3_M21_POS); 2474: 2475: AG903_PGPn(id)->CSC2PRM3 = val; 2476: } 2477: 2478: 2479: 2487: void AG903_PgpPrmGetPGPnCSC2PRM3(uint32_t id, uint32_t *m22, uint32_t *m21) 2488: { 2489: uint32_t val; 2490: 2491: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 2492: ASSERT(m22 != NULL); 2493: ASSERT(m21 != NULL); 2494: 2495: val = AG903_PGPn(id)->CSC2PRM3; 2496: 2497: *m22 = (val & AG903_PGPn_CSC2PRM3_M22_MSK) >> AG903_PGPn_CSC2PRM3_M22_POS; 2498: *m21 = (val & AG903_PGPn_CSC2PRM3_M21_MSK) >> AG903_PGPn_CSC2PRM3_M21_POS; 2499: } 2500: 2501: 2502: 2509: void AG903_PgpPrmSetPGPnCSC2PRM4(uint32_t id, uint32_t m23) 2510: { 2511: uint32_t val; 2512: 2513: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 2514: ASSERT(!(m23 & ~(0xFFF))); 2515: 2516: val = (m23 << AG903_PGPn_CSC2PRM4_M23_POS); 2517: 2518: AG903_PGPn(id)->CSC2PRM4 = val; 2519: } 2520: 2521: 2522: 2529: void AG903_PgpPrmGetPGPnCSC2PRM4(uint32_t id, uint32_t *m23) 2530: { 2531: uint32_t val; 2532: 2533: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 2534: ASSERT(m23 != NULL); 2535: 2536: val = AG903_PGPn(id)->CSC2PRM4; 2537: 2538: *m23 = (val & AG903_PGPn_CSC2PRM4_M23_MSK) >> AG903_PGPn_CSC2PRM4_M23_POS; 2539: } 2540: 2541: 2542: 2549: void AG903_PgpPrmSetPGPnCSC2PRM5(uint32_t id, uint32_t m24) 2550: { 2551: uint32_t val; 2552: 2553: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 2554: ASSERT(!(m24 & ~(0xFFFFF))); 2555: 2556: val = (m24 << AG903_PGPn_CSC2PRM5_M24_POS); 2557: 2558: AG903_PGPn(id)->CSC2PRM5 = val; 2559: } 2560: 2561: 2562: 2569: void AG903_PgpPrmGetPGPnCSC2PRM5(uint32_t id, uint32_t *m24) 2570: { 2571: uint32_t val; 2572: 2573: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 2574: ASSERT(m24 != NULL); 2575: 2576: val = AG903_PGPn(id)->CSC2PRM5; 2577: 2578: *m24 = (val & AG903_PGPn_CSC2PRM5_M24_MSK) >> AG903_PGPn_CSC2PRM5_M24_POS; 2579: } 2580: 2581: 2582: 2590: void AG903_PgpPrmSetPGPnCSC2PRM6(uint32_t id, uint32_t m32, uint32_t m31) 2591: { 2592: uint32_t val; 2593: 2594: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 2595: ASSERT(!(m32 & ~(0xFFF))); 2596: ASSERT(!(m31 & ~(0xFFF))); 2597: 2598: val = (m32 << AG903_PGPn_CSC2PRM6_M32_POS) 2599: | (m31 << AG903_PGPn_CSC2PRM6_M31_POS); 2600: 2601: AG903_PGPn(id)->CSC2PRM6 = val; 2602: } 2603: 2604: 2605: 2613: void AG903_PgpPrmGetPGPnCSC2PRM6(uint32_t id, uint32_t *m32, uint32_t *m31) 2614: { 2615: uint32_t val; 2616: 2617: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 2618: ASSERT(m32 != NULL); 2619: ASSERT(m31 != NULL); 2620: 2621: val = AG903_PGPn(id)->CSC2PRM6; 2622: 2623: *m32 = (val & AG903_PGPn_CSC2PRM6_M32_MSK) >> AG903_PGPn_CSC2PRM6_M32_POS; 2624: *m31 = (val & AG903_PGPn_CSC2PRM6_M31_MSK) >> AG903_PGPn_CSC2PRM6_M31_POS; 2625: } 2626: 2627: 2628: 2635: void AG903_PgpPrmSetPGPnCSC2PRM7(uint32_t id, uint32_t m33) 2636: { 2637: uint32_t val; 2638: 2639: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 2640: ASSERT(!(m33 & ~(0xFFF))); 2641: 2642: val = (m33 << AG903_PGPn_CSC2PRM7_M33_POS); 2643: 2644: AG903_PGPn(id)->CSC2PRM7 = val; 2645: } 2646: 2647: 2648: 2655: void AG903_PgpPrmGetPGPnCSC2PRM7(uint32_t id, uint32_t *m33) 2656: { 2657: uint32_t val; 2658: 2659: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 2660: ASSERT(m33 != NULL); 2661: 2662: val = AG903_PGPn(id)->CSC2PRM7; 2663: 2664: *m33 = (val & AG903_PGPn_CSC2PRM7_M33_MSK) >> AG903_PGPn_CSC2PRM7_M33_POS; 2665: } 2666: 2667: 2668: 2675: void AG903_PgpPrmSetPGPnCSC2PRM8(uint32_t id, uint32_t m34) 2676: { 2677: uint32_t val; 2678: 2679: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 2680: ASSERT(!(m34 & ~(0xFFFFF))); 2681: 2682: val = (m34 << AG903_PGPn_CSC2PRM8_M34_POS); 2683: 2684: AG903_PGPn(id)->CSC2PRM8 = val; 2685: } 2686: 2687: 2688: 2695: void AG903_PgpPrmGetPGPnCSC2PRM8(uint32_t id, uint32_t *m34) 2696: { 2697: uint32_t val; 2698: 2699: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 2700: ASSERT(m34 != NULL); 2701: 2702: val = AG903_PGPn(id)->CSC2PRM8; 2703: 2704: *m34 = (val & AG903_PGPn_CSC2PRM8_M34_MSK) >> AG903_PGPn_CSC2PRM8_M34_POS; 2705: } 2706: 2707: 2708: 2717: void AG903_PgpPrmSetPGPnMSK0PRM0(uint32_t id, uint32_t h, uint32_t l, uint32_t x) 2718: { 2719: uint32_t val; 2720: 2721: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 2722: ASSERT(!(h & ~(0x1))); 2723: ASSERT(!(l & ~(0x1))); 2724: ASSERT(!(x & ~(0x1))); 2725: 2726: val = (h << AG903_PGPn_MSK0PRM0_H_POS) 2727: | (l << AG903_PGPn_MSK0PRM0_L_POS) 2728: | (x << AG903_PGPn_MSK0PRM0_X_POS); 2729: 2730: AG903_PGPn(id)->MSK0PRM0 = val; 2731: } 2732: 2733: 2734: 2743: void AG903_PgpPrmGetPGPnMSK0PRM0(uint32_t id, uint32_t *h, uint32_t *l, uint32_t *x) 2744: { 2745: uint32_t val; 2746: 2747: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 2748: ASSERT(h != NULL); 2749: ASSERT(l != NULL); 2750: ASSERT(x != NULL); 2751: 2752: val = AG903_PGPn(id)->MSK0PRM0; 2753: 2754: *h = (val & AG903_PGPn_MSK0PRM0_H_MSK) >> AG903_PGPn_MSK0PRM0_H_POS; 2755: *l = (val & AG903_PGPn_MSK0PRM0_L_MSK) >> AG903_PGPn_MSK0PRM0_L_POS; 2756: *x = (val & AG903_PGPn_MSK0PRM0_X_MSK) >> AG903_PGPn_MSK0PRM0_X_POS; 2757: } 2758: 2759: 2760: 2767: void AG903_PgpPrmSetPGPnMSK0PRM1(uint32_t id, PGPPrmParamPGPnMSK0PRM1 *msk0prm1) 2768: { 2769: uint32_t val; 2770: 2771: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 2772: ASSERT(msk0prm1 != NULL); 2773: ASSERT(!(msk0prm1->hmax & ~(0xFF))); 2774: ASSERT(!(msk0prm1->hmin & ~(0xFF))); 2775: ASSERT(!(msk0prm1->lmax & ~(0xFF))); 2776: ASSERT(!(msk0prm1->lmin & ~(0xFF))); 2777: 2778: val = (msk0prm1->hmax << AG903_PGPn_MSK0PRM1_HMAX_POS) 2779: | (msk0prm1->hmin << AG903_PGPn_MSK0PRM1_HMIN_POS) 2780: | (msk0prm1->lmax << AG903_PGPn_MSK0PRM1_LMAX_POS) 2781: | (msk0prm1->lmin << AG903_PGPn_MSK0PRM1_LMIN_POS); 2782: 2783: AG903_PGPn(id)->MSK0PRM1 = val; 2784: } 2785: 2786: 2787: 2794: void AG903_PgpPrmGetPGPnMSK0PRM1(uint32_t id, PGPPrmParamPGPnMSK0PRM1 *msk0prm1) 2795: { 2796: uint32_t val; 2797: 2798: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 2799: ASSERT(msk0prm1 != NULL); 2800: 2801: val = AG903_PGPn(id)->MSK0PRM1; 2802: 2803: msk0prm1->hmax = (val & AG903_PGPn_MSK0PRM1_HMAX_MSK) >> AG903_PGPn_MSK0PRM1_HMAX_POS; 2804: msk0prm1->hmin = (val & AG903_PGPn_MSK0PRM1_HMIN_MSK) >> AG903_PGPn_MSK0PRM1_HMIN_POS; 2805: msk0prm1->lmax = (val & AG903_PGPn_MSK0PRM1_LMAX_MSK) >> AG903_PGPn_MSK0PRM1_LMAX_POS; 2806: msk0prm1->lmin = (val & AG903_PGPn_MSK0PRM1_LMIN_MSK) >> AG903_PGPn_MSK0PRM1_LMIN_POS; 2807: } 2808: 2809: 2810: 2819: void AG903_PgpPrmSetPGPnMSK1PRM0(uint32_t id, uint32_t h, uint32_t l, uint32_t x) 2820: { 2821: uint32_t val; 2822: 2823: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 2824: ASSERT(!(h & ~(0x1))); 2825: ASSERT(!(l & ~(0x1))); 2826: ASSERT(!(x & ~(0x1))); 2827: 2828: val = (h << AG903_PGPn_MSK1PRM0_H_POS) 2829: | (l << AG903_PGPn_MSK1PRM0_L_POS) 2830: | (x << AG903_PGPn_MSK1PRM0_X_POS); 2831: 2832: AG903_PGPn(id)->MSK1PRM0 = val; 2833: } 2834: 2835: 2836: 2845: void AG903_PgpPrmGetPGPnMSK1PRM0(uint32_t id, uint32_t *h, uint32_t *l, uint32_t *x) 2846: { 2847: uint32_t val; 2848: 2849: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 2850: ASSERT(h != NULL); 2851: ASSERT(l != NULL); 2852: ASSERT(x != NULL); 2853: 2854: val = AG903_PGPn(id)->MSK1PRM0; 2855: 2856: *h = (val & AG903_PGPn_MSK1PRM0_H_MSK) >> AG903_PGPn_MSK1PRM0_H_POS; 2857: *l = (val & AG903_PGPn_MSK1PRM0_L_MSK) >> AG903_PGPn_MSK1PRM0_L_POS; 2858: *x = (val & AG903_PGPn_MSK1PRM0_X_MSK) >> AG903_PGPn_MSK1PRM0_X_POS; 2859: } 2860: 2861: 2862: 2869: void AG903_PgpPrmSetPGPnMSK1PRM1(uint32_t id, PGPPrmParamPGPnMSK1PRM1 *msk1prm1) 2870: { 2871: uint32_t val; 2872: 2873: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 2874: ASSERT(msk1prm1 != NULL); 2875: ASSERT(!(msk1prm1->hmax & ~(0xFF))); 2876: ASSERT(!(msk1prm1->hmin & ~(0xFF))); 2877: ASSERT(!(msk1prm1->lmax & ~(0xFF))); 2878: ASSERT(!(msk1prm1->lmin & ~(0xFF))); 2879: 2880: val = (msk1prm1->hmax << AG903_PGPn_MSK1PRM1_HMAX_POS) 2881: | (msk1prm1->hmin << AG903_PGPn_MSK1PRM1_HMIN_POS) 2882: | (msk1prm1->lmax << AG903_PGPn_MSK1PRM1_LMAX_POS) 2883: | (msk1prm1->lmin << AG903_PGPn_MSK1PRM1_LMIN_POS); 2884: 2885: AG903_PGPn(id)->MSK1PRM1 = val; 2886: } 2887: 2888: 2889: 2896: void AG903_PgpPrmGetPGPnMSK1PRM1(uint32_t id, PGPPrmParamPGPnMSK1PRM1 *msk1prm1) 2897: { 2898: uint32_t val; 2899: 2900: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 2901: ASSERT(msk1prm1 != NULL); 2902: 2903: val = AG903_PGPn(id)->MSK1PRM1; 2904: 2905: msk1prm1->hmax = (val & AG903_PGPn_MSK1PRM1_HMAX_MSK) >> AG903_PGPn_MSK1PRM1_HMAX_POS; 2906: msk1prm1->hmin = (val & AG903_PGPn_MSK1PRM1_HMIN_MSK) >> AG903_PGPn_MSK1PRM1_HMIN_POS; 2907: msk1prm1->lmax = (val & AG903_PGPn_MSK1PRM1_LMAX_MSK) >> AG903_PGPn_MSK1PRM1_LMAX_POS; 2908: msk1prm1->lmin = (val & AG903_PGPn_MSK1PRM1_LMIN_MSK) >> AG903_PGPn_MSK1PRM1_LMIN_POS; 2909: } 2910: 2911: 2912: 2921: void AG903_PgpPrmSetPGPnMSK2PRM0(uint32_t id, uint32_t h, uint32_t l, uint32_t x) 2922: { 2923: uint32_t val; 2924: 2925: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 2926: ASSERT(!(h & ~(0x1))); 2927: ASSERT(!(l & ~(0x1))); 2928: ASSERT(!(x & ~(0x1))); 2929: 2930: val = (h << AG903_PGPn_MSK2PRM0_H_POS) 2931: | (l << AG903_PGPn_MSK2PRM0_L_POS) 2932: | (x << AG903_PGPn_MSK2PRM0_X_POS); 2933: 2934: AG903_PGPn(id)->MSK2PRM0 = val; 2935: } 2936: 2937: 2938: 2947: void AG903_PgpPrmGetPGPnMSK2PRM0(uint32_t id, uint32_t *h, uint32_t *l, uint32_t *x) 2948: { 2949: uint32_t val; 2950: 2951: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 2952: ASSERT(h != NULL); 2953: ASSERT(l != NULL); 2954: ASSERT(x != NULL); 2955: 2956: val = AG903_PGPn(id)->MSK2PRM0; 2957: 2958: *h = (val & AG903_PGPn_MSK2PRM0_H_MSK) >> AG903_PGPn_MSK2PRM0_H_POS; 2959: *l = (val & AG903_PGPn_MSK2PRM0_L_MSK) >> AG903_PGPn_MSK2PRM0_L_POS; 2960: *x = (val & AG903_PGPn_MSK2PRM0_X_MSK) >> AG903_PGPn_MSK2PRM0_X_POS; 2961: } 2962: 2963: 2964: 2971: void AG903_PgpPrmSetPGPnMSK2PRM1(uint32_t id, PGPPrmParamPGPnMSK2PRM1 *msk2prm1) 2972: { 2973: uint32_t val; 2974: 2975: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 2976: ASSERT(msk2prm1 != NULL); 2977: ASSERT(!(msk2prm1->hmax & ~(0xFF))); 2978: ASSERT(!(msk2prm1->hmin & ~(0xFF))); 2979: ASSERT(!(msk2prm1->lmax & ~(0xFF))); 2980: ASSERT(!(msk2prm1->lmin & ~(0xFF))); 2981: 2982: val = (msk2prm1->hmax << AG903_PGPn_MSK2PRM1_HMAX_POS) 2983: | (msk2prm1->hmin << AG903_PGPn_MSK2PRM1_HMIN_POS) 2984: | (msk2prm1->lmax << AG903_PGPn_MSK2PRM1_LMAX_POS) 2985: | (msk2prm1->lmin << AG903_PGPn_MSK2PRM1_LMIN_POS); 2986: 2987: AG903_PGPn(id)->MSK2PRM1 = val; 2988: } 2989: 2990: 2991: 2998: void AG903_PgpPrmGetPGPnMSK2PRM1(uint32_t id, PGPPrmParamPGPnMSK2PRM1 *msk2prm1) 2999: { 3000: uint32_t val; 3001: 3002: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 3003: ASSERT(msk2prm1 != NULL); 3004: 3005: val = AG903_PGPn(id)->MSK2PRM1; 3006: 3007: msk2prm1->hmax = (val & AG903_PGPn_MSK2PRM1_HMAX_MSK) >> AG903_PGPn_MSK2PRM1_HMAX_POS; 3008: msk2prm1->hmin = (val & AG903_PGPn_MSK2PRM1_HMIN_MSK) >> AG903_PGPn_MSK2PRM1_HMIN_POS; 3009: msk2prm1->lmax = (val & AG903_PGPn_MSK2PRM1_LMAX_MSK) >> AG903_PGPn_MSK2PRM1_LMAX_POS; 3010: msk2prm1->lmin = (val & AG903_PGPn_MSK2PRM1_LMIN_MSK) >> AG903_PGPn_MSK2PRM1_LMIN_POS; 3011: } 3012: 3013: 3014: 3021: void AG903_PgpPrmSetPGPnTHR8PRM0(uint32_t id, PGPPrmParamPGPnTHR8PRM0 *thr8prm0) 3022: { 3023: uint32_t val; 3024: 3025: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 3026: ASSERT(thr8prm0 != NULL); 3027: ASSERT(!(thr8prm0->type & ~(0xF))); 3028: ASSERT(!(thr8prm0->maxval & ~(0xFF))); 3029: ASSERT(!(thr8prm0->maxthr & ~(0xFF))); 3030: ASSERT(!(thr8prm0->minthr & ~(0xFF))); 3031: 3032: val = (thr8prm0->type << AG903_PGPn_THR8PRM0_TYPE_POS) 3033: | (thr8prm0->maxval << AG903_PGPn_THR8PRM0_MAXVAL_POS) 3034: | (thr8prm0->maxthr << AG903_PGPn_THR8PRM0_MAXTHR_POS) 3035: | (thr8prm0->minthr << AG903_PGPn_THR8PRM0_MINTHR_POS); 3036: 3037: AG903_PGPn(id)->THR8PRM0 = val; 3038: } 3039: 3040: 3041: 3048: void AG903_PgpPrmGetPGPnTHR8PRM0(uint32_t id, PGPPrmParamPGPnTHR8PRM0 *thr8prm0) 3049: { 3050: uint32_t val; 3051: 3052: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 3053: ASSERT(thr8prm0 != NULL); 3054: 3055: val = AG903_PGPn(id)->THR8PRM0; 3056: 3057: thr8prm0->type = (val & AG903_PGPn_THR8PRM0_TYPE_MSK) >> AG903_PGPn_THR8PRM0_TYPE_POS; 3058: thr8prm0->maxval = (val & AG903_PGPn_THR8PRM0_MAXVAL_MSK) >> AG903_PGPn_THR8PRM0_MAXVAL_POS; 3059: thr8prm0->maxthr = (val & AG903_PGPn_THR8PRM0_MAXTHR_MSK) >> AG903_PGPn_THR8PRM0_MAXTHR_POS; 3060: thr8prm0->minthr = (val & AG903_PGPn_THR8PRM0_MINTHR_MSK) >> AG903_PGPn_THR8PRM0_MINTHR_POS; 3061: } 3062: 3063: 3064: 3071: void AG903_PgpPrmSetPGPnTHR8PRM1(uint32_t id, PGPPrmParamPGPnTHR8PRM1 *thr8prm1) 3072: { 3073: uint32_t val; 3074: 3075: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 3076: ASSERT(thr8prm1 != NULL); 3077: ASSERT(!(thr8prm1->type & ~(0xF))); 3078: ASSERT(!(thr8prm1->maxval & ~(0xFF))); 3079: ASSERT(!(thr8prm1->maxthr & ~(0xFF))); 3080: ASSERT(!(thr8prm1->minthr & ~(0xFF))); 3081: 3082: val = (thr8prm1->type << AG903_PGPn_THR8PRM1_TYPE_POS) 3083: | (thr8prm1->maxval << AG903_PGPn_THR8PRM1_MAXVAL_POS) 3084: | (thr8prm1->maxthr << AG903_PGPn_THR8PRM1_MAXTHR_POS) 3085: | (thr8prm1->minthr << AG903_PGPn_THR8PRM1_MINTHR_POS); 3086: 3087: AG903_PGPn(id)->THR8PRM1 = val; 3088: } 3089: 3090: 3091: 3098: void AG903_PgpPrmGetPGPnTHR8PRM1(uint32_t id, PGPPrmParamPGPnTHR8PRM1 *thr8prm1) 3099: { 3100: uint32_t val; 3101: 3102: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 3103: ASSERT(thr8prm1 != NULL); 3104: 3105: val = AG903_PGPn(id)->THR8PRM1; 3106: 3107: thr8prm1->type = (val & AG903_PGPn_THR8PRM1_TYPE_MSK) >> AG903_PGPn_THR8PRM1_TYPE_POS; 3108: thr8prm1->maxval = (val & AG903_PGPn_THR8PRM1_MAXVAL_MSK) >> AG903_PGPn_THR8PRM1_MAXVAL_POS; 3109: thr8prm1->maxthr = (val & AG903_PGPn_THR8PRM1_MAXTHR_MSK) >> AG903_PGPn_THR8PRM1_MAXTHR_POS; 3110: thr8prm1->minthr = (val & AG903_PGPn_THR8PRM1_MINTHR_MSK) >> AG903_PGPn_THR8PRM1_MINTHR_POS; 3111: } 3112: 3113: 3114: 3121: void AG903_PgpPrmSetPGPnTHR8PRM2(uint32_t id, PGPPrmParamPGPnTHR8PRM2 *thr8prm2) 3122: { 3123: uint32_t val; 3124: 3125: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 3126: ASSERT(thr8prm2 != NULL); 3127: ASSERT(!(thr8prm2->type & ~(0xF))); 3128: ASSERT(!(thr8prm2->maxval & ~(0xFF))); 3129: ASSERT(!(thr8prm2->maxthr & ~(0xFF))); 3130: ASSERT(!(thr8prm2->minthr & ~(0xFF))); 3131: 3132: val = (thr8prm2->type << AG903_PGPn_THR8PRM2_TYPE_POS) 3133: | (thr8prm2->maxval << AG903_PGPn_THR8PRM2_MAXVAL_POS) 3134: | (thr8prm2->maxthr << AG903_PGPn_THR8PRM2_MAXTHR_POS) 3135: | (thr8prm2->minthr << AG903_PGPn_THR8PRM2_MINTHR_POS); 3136: 3137: AG903_PGPn(id)->THR8PRM2 = val; 3138: } 3139: 3140: 3141: 3148: void AG903_PgpPrmGetPGPnTHR8PRM2(uint32_t id, PGPPrmParamPGPnTHR8PRM2 *thr8prm2) 3149: { 3150: uint32_t val; 3151: 3152: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 3153: ASSERT(thr8prm2 != NULL); 3154: 3155: val = AG903_PGPn(id)->THR8PRM2; 3156: 3157: thr8prm2->type = (val & AG903_PGPn_THR8PRM2_TYPE_MSK) >> AG903_PGPn_THR8PRM2_TYPE_POS; 3158: thr8prm2->maxval = (val & AG903_PGPn_THR8PRM2_MAXVAL_MSK) >> AG903_PGPn_THR8PRM2_MAXVAL_POS; 3159: thr8prm2->maxthr = (val & AG903_PGPn_THR8PRM2_MAXTHR_MSK) >> AG903_PGPn_THR8PRM2_MAXTHR_POS; 3160: thr8prm2->minthr = (val & AG903_PGPn_THR8PRM2_MINTHR_MSK) >> AG903_PGPn_THR8PRM2_MINTHR_POS; 3161: } 3162: 3163: 3164: 3173: void AG903_PgpPrmSetPGPnTHR1PRM0(uint32_t id, uint32_t h, uint32_t l, uint32_t x) 3174: { 3175: uint32_t val; 3176: 3177: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 3178: ASSERT(!(h & ~(0x1))); 3179: ASSERT(!(l & ~(0x1))); 3180: ASSERT(!(x & ~(0x1))); 3181: 3182: val = (h << AG903_PGPn_THR1PRM0_H_POS) 3183: | (l << AG903_PGPn_THR1PRM0_L_POS) 3184: | (x << AG903_PGPn_THR1PRM0_X_POS); 3185: 3186: AG903_PGPn(id)->THR1PRM0 = val; 3187: } 3188: 3189: 3190: 3199: void AG903_PgpPrmGetPGPnTHR1PRM0(uint32_t id, uint32_t *h, uint32_t *l, uint32_t *x) 3200: { 3201: uint32_t val; 3202: 3203: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 3204: ASSERT(h != NULL); 3205: ASSERT(l != NULL); 3206: ASSERT(x != NULL); 3207: 3208: val = AG903_PGPn(id)->THR1PRM0; 3209: 3210: *h = (val & AG903_PGPn_THR1PRM0_H_MSK) >> AG903_PGPn_THR1PRM0_H_POS; 3211: *l = (val & AG903_PGPn_THR1PRM0_L_MSK) >> AG903_PGPn_THR1PRM0_L_POS; 3212: *x = (val & AG903_PGPn_THR1PRM0_X_MSK) >> AG903_PGPn_THR1PRM0_X_POS; 3213: } 3214: 3215: 3216: 3223: void AG903_PgpPrmSetPGPnTHR1PRM1(uint32_t id, PGPPrmParamPGPnTHR1PRM1 *thr1prm1) 3224: { 3225: uint32_t val; 3226: 3227: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 3228: ASSERT(thr1prm1 != NULL); 3229: ASSERT(!(thr1prm1->hmax & ~(0xFF))); 3230: ASSERT(!(thr1prm1->hmin & ~(0xFF))); 3231: ASSERT(!(thr1prm1->lmax & ~(0xFF))); 3232: ASSERT(!(thr1prm1->lmin & ~(0xFF))); 3233: 3234: val = (thr1prm1->hmax << AG903_PGPn_THR1PRM1_HMAX_POS) 3235: | (thr1prm1->hmin << AG903_PGPn_THR1PRM1_HMIN_POS) 3236: | (thr1prm1->lmax << AG903_PGPn_THR1PRM1_LMAX_POS) 3237: | (thr1prm1->lmin << AG903_PGPn_THR1PRM1_LMIN_POS); 3238: 3239: AG903_PGPn(id)->THR1PRM1 = val; 3240: } 3241: 3242: 3243: 3250: void AG903_PgpPrmGetPGPnTHR1PRM1(uint32_t id, PGPPrmParamPGPnTHR1PRM1 *thr1prm1) 3251: { 3252: uint32_t val; 3253: 3254: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 3255: ASSERT(thr1prm1 != NULL); 3256: 3257: val = AG903_PGPn(id)->THR1PRM1; 3258: 3259: thr1prm1->hmax = (val & AG903_PGPn_THR1PRM1_HMAX_MSK) >> AG903_PGPn_THR1PRM1_HMAX_POS; 3260: thr1prm1->hmin = (val & AG903_PGPn_THR1PRM1_HMIN_MSK) >> AG903_PGPn_THR1PRM1_HMIN_POS; 3261: thr1prm1->lmax = (val & AG903_PGPn_THR1PRM1_LMAX_MSK) >> AG903_PGPn_THR1PRM1_LMAX_POS; 3262: thr1prm1->lmin = (val & AG903_PGPn_THR1PRM1_LMIN_MSK) >> AG903_PGPn_THR1PRM1_LMIN_POS; 3263: } 3264: 3265: 3266: 3273: void AG903_PgpPrmSetPGPnSPF1PRM0(uint32_t id, PGPPrmParamPGPnSPF1PRM0 *spf1prm0) 3274: { 3275: uint32_t val; 3276: 3277: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 3278: ASSERT(spf1prm0 != NULL); 3279: ASSERT(!(spf1prm0->h10 & ~(0x7))); 3280: ASSERT(!(spf1prm0->h00 & ~(0x7))); 3281: ASSERT(!(spf1prm0->hm0 & ~(0x7))); 3282: ASSERT(!(spf1prm0->h1m & ~(0x7))); 3283: ASSERT(!(spf1prm0->h0m & ~(0x7))); 3284: ASSERT(!(spf1prm0->hmm & ~(0x7))); 3285: 3286: val = (spf1prm0->h10 << AG903_PGPn_SPF1PRM0_H10_POS) 3287: | (spf1prm0->h00 << AG903_PGPn_SPF1PRM0_H00_POS) 3288: | (spf1prm0->hm0 << AG903_PGPn_SPF1PRM0_HM0_POS) 3289: | (spf1prm0->h1m << AG903_PGPn_SPF1PRM0_H1M_POS) 3290: | (spf1prm0->h0m << AG903_PGPn_SPF1PRM0_H0M_POS) 3291: | (spf1prm0->hmm << AG903_PGPn_SPF1PRM0_HMM_POS); 3292: 3293: AG903_PGPn(id)->SPF1PRM0 = val; 3294: } 3295: 3296: 3297: 3304: void AG903_PgpPrmGetPGPnSPF1PRM0(uint32_t id, PGPPrmParamPGPnSPF1PRM0 *spf1prm0) 3305: { 3306: uint32_t val; 3307: 3308: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 3309: ASSERT(spf1prm0 != NULL); 3310: 3311: val = AG903_PGPn(id)->SPF1PRM0; 3312: 3313: spf1prm0->h10 = (val & AG903_PGPn_SPF1PRM0_H10_MSK) >> AG903_PGPn_SPF1PRM0_H10_POS; 3314: spf1prm0->h00 = (val & AG903_PGPn_SPF1PRM0_H00_MSK) >> AG903_PGPn_SPF1PRM0_H00_POS; 3315: spf1prm0->hm0 = (val & AG903_PGPn_SPF1PRM0_HM0_MSK) >> AG903_PGPn_SPF1PRM0_HM0_POS; 3316: spf1prm0->h1m = (val & AG903_PGPn_SPF1PRM0_H1M_MSK) >> AG903_PGPn_SPF1PRM0_H1M_POS; 3317: spf1prm0->h0m = (val & AG903_PGPn_SPF1PRM0_H0M_MSK) >> AG903_PGPn_SPF1PRM0_H0M_POS; 3318: spf1prm0->hmm = (val & AG903_PGPn_SPF1PRM0_HMM_MSK) >> AG903_PGPn_SPF1PRM0_HMM_POS; 3319: } 3320: 3321: 3322: 3329: void AG903_PgpPrmSetPGPnSPF1PRM1(uint32_t id, PGPPrmParamPGPnSPF1PRM1 *spf1prm1) 3330: { 3331: uint32_t val; 3332: 3333: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 3334: ASSERT(spf1prm1 != NULL); 3335: ASSERT(!(spf1prm1->thr & ~(0x3F))); 3336: ASSERT(!(spf1prm1->h11 & ~(0x7))); 3337: ASSERT(!(spf1prm1->h01 & ~(0x7))); 3338: ASSERT(!(spf1prm1->hm1 & ~(0x7))); 3339: 3340: val = (spf1prm1->thr << AG903_PGPn_SPF1PRM1_THR_POS) 3341: | (spf1prm1->h11 << AG903_PGPn_SPF1PRM1_H11_POS) 3342: | (spf1prm1->h01 << AG903_PGPn_SPF1PRM1_H01_POS) 3343: | (spf1prm1->hm1 << AG903_PGPn_SPF1PRM1_HM1_POS); 3344: 3345: AG903_PGPn(id)->SPF1PRM1 = val; 3346: } 3347: 3348: 3349: 3356: void AG903_PgpPrmGetPGPnSPF1PRM1(uint32_t id, PGPPrmParamPGPnSPF1PRM1 *spf1prm1) 3357: { 3358: uint32_t val; 3359: 3360: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 3361: ASSERT(spf1prm1 != NULL); 3362: 3363: val = AG903_PGPn(id)->SPF1PRM1; 3364: 3365: spf1prm1->thr = (val & AG903_PGPn_SPF1PRM1_THR_MSK) >> AG903_PGPn_SPF1PRM1_THR_POS; 3366: spf1prm1->h11 = (val & AG903_PGPn_SPF1PRM1_H11_MSK) >> AG903_PGPn_SPF1PRM1_H11_POS; 3367: spf1prm1->h01 = (val & AG903_PGPn_SPF1PRM1_H01_MSK) >> AG903_PGPn_SPF1PRM1_H01_POS; 3368: spf1prm1->hm1 = (val & AG903_PGPn_SPF1PRM1_HM1_MSK) >> AG903_PGPn_SPF1PRM1_HM1_POS; 3369: } 3370: 3371: 3372: 3379: void AG903_PgpPrmGetPGPnTHR1CNT(uint32_t id, uint32_t *cnt) 3380: { 3381: uint32_t val; 3382: 3383: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 3384: ASSERT(cnt != NULL); 3385: 3386: val = AG903_PGPn(id)->THR1CNT; 3387: 3388: *cnt = (val & AG903_PGPn_THR1CNT_CNT_MSK) >> AG903_PGPn_THR1CNT_CNT_POS; 3389: } 3390: 3391: 3392: 3399: void AG903_PgpPrmSetPGPnLBLCMD(uint32_t id, uint32_t cmd) 3400: { 3401: uint32_t val; 3402: 3403: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 3404: ASSERT(!(cmd & ~(0x7))); 3405: 3406: val = (cmd << AG903_PGPn_LBLCMD_CMD_POS); 3407: 3408: AG903_PGPn(id)->LBLCMD = val; 3409: } 3410: 3411: 3412: 3419: void AG903_PgpPrmSetPGPnLBLCTRL(uint32_t id, PGPPrmParamPGPnLBLCTRL *lblctrl) 3420: { 3421: uint32_t val; 3422: 3423: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 3424: ASSERT(lblctrl != NULL); 3425: ASSERT(!(lblctrl->vld & ~(0xF))); 3426: ASSERT(!(lblctrl->inv & ~(0xF))); 3427: ASSERT(!(lblctrl->cnct & ~(0x1))); 3428: ASSERT(!(lblctrl->bmu & ~(0x1))); 3429: ASSERT(!(lblctrl->flthr & ~(0xFF))); 3430: ASSERT(!(lblctrl->maxid & ~(0xFF))); 3431: 3432: val = (lblctrl->vld << AG903_PGPn_LBLCTRL_VLD_POS) 3433: | (lblctrl->inv << AG903_PGPn_LBLCTRL_INV_POS) 3434: | (lblctrl->cnct << AG903_PGPn_LBLCTRL_CNCT_POS) 3435: | (lblctrl->bmu << AG903_PGPn_LBLCTRL_BMU_POS) 3436: | (lblctrl->flthr << AG903_PGPn_LBLCTRL_FLTHR_POS) 3437: | (lblctrl->maxid << AG903_PGPn_LBLCTRL_MAXID_POS); 3438: 3439: AG903_PGPn(id)->LBLCTRL = val; 3440: } 3441: 3442: 3443: 3450: void AG903_PgpPrmGetPGPnLBLCTRL(uint32_t id, PGPPrmParamPGPnLBLCTRL *lblctrl) 3451: { 3452: uint32_t val; 3453: 3454: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 3455: ASSERT(lblctrl != NULL); 3456: 3457: val = AG903_PGPn(id)->LBLCTRL; 3458: 3459: lblctrl->vld = (val & AG903_PGPn_LBLCTRL_VLD_MSK) >> AG903_PGPn_LBLCTRL_VLD_POS; 3460: lblctrl->inv = (val & AG903_PGPn_LBLCTRL_INV_MSK) >> AG903_PGPn_LBLCTRL_INV_POS; 3461: lblctrl->cnct = (val & AG903_PGPn_LBLCTRL_CNCT_MSK) >> AG903_PGPn_LBLCTRL_CNCT_POS; 3462: lblctrl->bmu = (val & AG903_PGPn_LBLCTRL_BMU_MSK) >> AG903_PGPn_LBLCTRL_BMU_POS; 3463: lblctrl->flthr = (val & AG903_PGPn_LBLCTRL_FLTHR_MSK) >> AG903_PGPn_LBLCTRL_FLTHR_POS; 3464: lblctrl->maxid = (val & AG903_PGPn_LBLCTRL_MAXID_MSK) >> AG903_PGPn_LBLCTRL_MAXID_POS; 3465: } 3466: 3467: 3468: 3476: void AG903_PgpPrmSetPGPnLBLSIZE(uint32_t id, uint32_t vsize, uint32_t hsize) 3477: { 3478: uint32_t val; 3479: 3480: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 3481: ASSERT(!(vsize & ~(0x3FF))); 3482: ASSERT(!(hsize & ~(0x3FF))); 3483: 3484: val = (vsize << AG903_PGPn_LBLSIZE_VSIZE_POS) 3485: | (hsize << AG903_PGPn_LBLSIZE_HSIZE_POS); 3486: 3487: AG903_PGPn(id)->LBLSIZE = val; 3488: } 3489: 3490: 3491: 3499: void AG903_PgpPrmGetPGPnLBLSIZE(uint32_t id, uint32_t *vsize, uint32_t *hsize) 3500: { 3501: uint32_t val; 3502: 3503: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 3504: ASSERT(vsize != NULL); 3505: ASSERT(hsize != NULL); 3506: 3507: val = AG903_PGPn(id)->LBLSIZE; 3508: 3509: *vsize = (val & AG903_PGPn_LBLSIZE_VSIZE_MSK) >> AG903_PGPn_LBLSIZE_VSIZE_POS; 3510: *hsize = (val & AG903_PGPn_LBLSIZE_HSIZE_MSK) >> AG903_PGPn_LBLSIZE_HSIZE_POS; 3511: } 3512: 3513: 3514: 3522: void AG903_PgpPrmSetPGPnLBLPOS(uint32_t id, uint32_t vpos, uint32_t hpos) 3523: { 3524: uint32_t val; 3525: 3526: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 3527: ASSERT(!(vpos & ~(0xFFF))); 3528: ASSERT(!(hpos & ~(0xFFF))); 3529: 3530: val = (vpos << AG903_PGPn_LBLPOS_VPOS_POS) 3531: | (hpos << AG903_PGPn_LBLPOS_HPOS_POS); 3532: 3533: AG903_PGPn(id)->LBLPOS = val; 3534: } 3535: 3536: 3537: 3545: void AG903_PgpPrmGetPGPnLBLPOS(uint32_t id, uint32_t *vpos, uint32_t *hpos) 3546: { 3547: uint32_t val; 3548: 3549: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 3550: ASSERT(vpos != NULL); 3551: ASSERT(hpos != NULL); 3552: 3553: val = AG903_PGPn(id)->LBLPOS; 3554: 3555: *vpos = (val & AG903_PGPn_LBLPOS_VPOS_MSK) >> AG903_PGPn_LBLPOS_VPOS_POS; 3556: *hpos = (val & AG903_PGPn_LBLPOS_HPOS_MSK) >> AG903_PGPn_LBLPOS_HPOS_POS; 3557: } 3558: 3559: 3560: 3567: void AG903_PgpPrmSetPGPnLBLDST(uint32_t id, uint32_t adr) 3568: { 3569: uint32_t val; 3570: 3571: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 3572: ASSERT(!(adr & ~(0x1FFFFFFF))); 3573: 3574: val = (adr << AG903_PGPn_LBLDST_ADR_POS); 3575: 3576: AG903_PGPn(id)->LBLDST = val; 3577: } 3578: 3579: 3580: 3587: void AG903_PgpPrmGetPGPnLBLDST(uint32_t id, uint32_t *adr) 3588: { 3589: uint32_t val; 3590: 3591: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 3592: ASSERT(adr != NULL); 3593: 3594: val = AG903_PGPn(id)->LBLDST; 3595: 3596: *adr = (val & AG903_PGPn_LBLDST_ADR_MSK) >> AG903_PGPn_LBLDST_ADR_POS; 3597: } 3598: 3599: 3600: 3607: void AG903_PgpPrmGetPGPnLBLSTAT(uint32_t id, PGPPrmParamPGPnLBLSTAT *lblstat) 3608: { 3609: uint32_t val; 3610: 3611: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 3612: ASSERT(lblstat != NULL); 3613: 3614: val = AG903_PGPn(id)->LBLSTAT; 3615: 3616: lblstat->l_id = (val & AG903_PGPn_LBLSTAT_ID_MSK) >> AG903_PGPn_LBLSTAT_ID_POS; 3617: lblstat->vrmacc = (val & AG903_PGPn_LBLSTAT_VRMACC_MSK) >> AG903_PGPn_LBLSTAT_VRMACC_POS; 3618: lblstat->act = (val & AG903_PGPn_LBLSTAT_ACT_MSK) >> AG903_PGPn_LBLSTAT_ACT_POS; 3619: lblstat->queue = (val & AG903_PGPn_LBLSTAT_QUEUE_MSK) >> AG903_PGPn_LBLSTAT_QUEUE_POS; 3620: lblstat->cmd = (val & AG903_PGPn_LBLSTAT_CMD_MSK) >> AG903_PGPn_LBLSTAT_CMD_POS; 3621: } 3622: 3623: 3624: 3631: void AG903_PgpPrmSetPGPnIFCCMD(uint32_t id, uint32_t cmd) 3632: { 3633: uint32_t val; 3634: 3635: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 3636: ASSERT(!(cmd & ~(0x7))); 3637: 3638: val = (cmd << AG903_PGPn_IFCCMD_CMD_POS); 3639: 3640: AG903_PGPn(id)->IFCCMD = val; 3641: } 3642: 3643: 3644: 3651: void AG903_PgpPrmSetPGPnIFCCTRL(uint32_t id, PGPPrmParamPGPnIFCCTRL *ifcctrl) 3652: { 3653: uint32_t val; 3654: 3655: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 3656: ASSERT(ifcctrl != NULL); 3657: ASSERT(!(ifcctrl->scan & ~(0x1))); 3658: ASSERT(!(ifcctrl->limit & ~(0x3))); 3659: ASSERT(!(ifcctrl->src & ~(0x3))); 3660: ASSERT(!(ifcctrl->op & ~(0x7))); 3661: ASSERT(!(ifcctrl->sft1 & ~(0x7))); 3662: ASSERT(!(ifcctrl->sft0 & ~(0x7))); 3663: 3664: val = (ifcctrl->scan << AG903_PGPn_IFCCTRL_SCAN_POS) 3665: | (ifcctrl->limit << AG903_PGPn_IFCCTRL_LIMIT_POS) 3666: | (ifcctrl->src << AG903_PGPn_IFCCTRL_SRC_POS) 3667: | (ifcctrl->op << AG903_PGPn_IFCCTRL_OP_POS) 3668: | (ifcctrl->sft1 << AG903_PGPn_IFCCTRL_SFT1_POS) 3669: | (ifcctrl->sft0 << AG903_PGPn_IFCCTRL_SFT0_POS); 3670: 3671: AG903_PGPn(id)->IFCCTRL = val; 3672: } 3673: 3674: 3675: 3682: void AG903_PgpPrmGetPGPnIFCCTRL(uint32_t id, PGPPrmParamPGPnIFCCTRL *ifcctrl) 3683: { 3684: uint32_t val; 3685: 3686: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 3687: ASSERT(ifcctrl != NULL); 3688: 3689: val = AG903_PGPn(id)->IFCCTRL; 3690: 3691: ifcctrl->scan = (val & AG903_PGPn_IFCCTRL_SCAN_MSK) >> AG903_PGPn_IFCCTRL_SCAN_POS; 3692: ifcctrl->limit = (val & AG903_PGPn_IFCCTRL_LIMIT_MSK) >> AG903_PGPn_IFCCTRL_LIMIT_POS; 3693: ifcctrl->src = (val & AG903_PGPn_IFCCTRL_SRC_MSK) >> AG903_PGPn_IFCCTRL_SRC_POS; 3694: ifcctrl->op = (val & AG903_PGPn_IFCCTRL_OP_MSK) >> AG903_PGPn_IFCCTRL_OP_POS; 3695: ifcctrl->sft1 = (val & AG903_PGPn_IFCCTRL_SFT1_MSK) >> AG903_PGPn_IFCCTRL_SFT1_POS; 3696: ifcctrl->sft0 = (val & AG903_PGPn_IFCCTRL_SFT0_MSK) >> AG903_PGPn_IFCCTRL_SFT0_POS; 3697: } 3698: 3699: 3700: 3708: void AG903_PgpPrmSetPGPnIFCPRM(uint32_t id, uint32_t gain1, uint32_t gain0) 3709: { 3710: uint32_t val; 3711: 3712: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 3713: ASSERT(!(gain1 & ~(0xFF))); 3714: ASSERT(!(gain0 & ~(0xFF))); 3715: 3716: val = (gain1 << AG903_PGPn_IFCPRM_GAIN1_POS) 3717: | (gain0 << AG903_PGPn_IFCPRM_GAIN0_POS); 3718: 3719: AG903_PGPn(id)->IFCPRM = val; 3720: } 3721: 3722: 3723: 3731: void AG903_PgpPrmGetPGPnIFCPRM(uint32_t id, uint32_t *gain1, uint32_t *gain0) 3732: { 3733: uint32_t val; 3734: 3735: ASSERT(id < AG903_PGP_PRM_MAX_PIPELINE); 3736: ASSERT(gain1 != NULL); 3737: ASSERT(gain0 != NULL); 3738: 3739: val = AG903_PGPn(id)->IFCPRM; 3740: 3741: *gain1 = (val & AG903_PGPn_IFCPRM_GAIN1_MSK) >> AG903_PGPn_IFCPRM_GAIN1_POS; 3742: *gain0 = (val & AG903_PGPn_IFCPRM_GAIN0_MSK) >> AG903_PGPn_IFCPRM_GAIN0_POS; 3743: } 3744: 3745: 3746: 3753: void AG903_PgpPrmSetPGPJPGOUTSEL(uint32_t en, uint32_t sel) 3754: { 3755: uint32_t val; 3756: 3757: ASSERT(!(en & ~(0x1))); 3758: ASSERT(!(sel & ~(0x7))); 3759: 3760: val = (en << AG903_PGP_JPGOUTSEL_EN_POS) 3761: | (sel << AG903_PGP_JPGOUTSEL_SEL_POS); 3762: 3763: AG903_PGP->JPGOUTSEL = val; 3764: } 3765: 3766: 3767: 3774: void AG903_PgpPrmGetPGPJPGOUTSEL(uint32_t *en, uint32_t *sel) 3775: { 3776: uint32_t val; 3777: 3778: ASSERT(en != NULL); 3779: ASSERT(sel != NULL); 3780: 3781: val = AG903_PGP->JPGOUTSEL; 3782: 3783: *en = (val & AG903_PGP_JPGOUTSEL_EN_MSK) >> AG903_PGP_JPGOUTSEL_EN_POS; 3784: *sel = (val & AG903_PGP_JPGOUTSEL_SEL_MSK) >> AG903_PGP_JPGOUTSEL_SEL_POS; 3785: } 3786: 3787: 3788: 3795: void AG903_PgpPrmSetPGPVInCMD(uint32_t id, uint32_t cmd) 3796: { 3797: uint32_t val; 3798: 3799: ASSERT(id < AG903_PGP_PRM_MAX_VRAMI); 3800: ASSERT(!(cmd & ~(0xF))); 3801: 3802: val = (cmd << AG903_PGPVIn_CMD_CMD_POS); 3803: 3804: AG903_PGPVIn(id)->CMD = val; 3805: } 3806: 3807: 3808: 3817: void AG903_PgpPrmGetPGPVInSTATE(uint32_t id, uint32_t *vrmacc, uint32_t *queue, uint32_t *st) 3818: { 3819: uint32_t val; 3820: 3821: ASSERT(id < AG903_PGP_PRM_MAX_VRAMI); 3822: ASSERT(vrmacc != NULL); 3823: ASSERT(queue != NULL); 3824: ASSERT(st != NULL); 3825: 3826: val = AG903_PGPVIn(id)->STATE; 3827: 3828: *vrmacc = (val & AG903_PGPVIn_STATE_VRMACC_MSK) >> AG903_PGPVIn_STATE_VRMACC_POS; 3829: *queue = (val & AG903_PGPVIn_STATE_QUEUE_MSK) >> AG903_PGPVIn_STATE_QUEUE_POS; 3830: *st = (val & AG903_PGPVIn_STATE_ST_MSK) >> AG903_PGPVIn_STATE_ST_POS; 3831: } 3832: 3833: 3834: 3841: void AG903_PgpPrmSetPGPVInCTRL0(uint32_t id, PGPPrmParamPGPVInCTRL0 *ctrl0) 3842: { 3843: uint32_t val; 3844: 3845: ASSERT(id < AG903_PGP_PRM_MAX_VRAMI); 3846: ASSERT(ctrl0 != NULL); 3847: ASSERT(!(ctrl0->fai & ~(0x1))); 3848: ASSERT(!(ctrl0->bmu & ~(0x3))); 3849: ASSERT(!(ctrl0->scan & ~(0x1))); 3850: ASSERT(!(ctrl0->dim & ~(0x1))); 3851: ASSERT(!(ctrl0->swapw & ~(0x1))); 3852: ASSERT(!(ctrl0->swaph & ~(0x1))); 3853: ASSERT(!(ctrl0->swap4 & ~(0x1))); 3854: ASSERT(!(ctrl0->swap1 & ~(0x1))); 3855: ASSERT(!(ctrl0->md & ~(0x7))); 3856: ASSERT(!(ctrl0->fmt & ~(0xF))); 3857: 3858: val = (ctrl0->fai << AG903_PGPVIn_CTRL0_FAI_POS) 3859: | (ctrl0->bmu << AG903_PGPVIn_CTRL0_BMU_POS) 3860: | (ctrl0->scan << AG903_PGPVIn_CTRL0_SCAN_POS) 3861: | (ctrl0->dim << AG903_PGPVIn_CTRL0_DIM_POS) 3862: | (ctrl0->swapw << AG903_PGPVIn_CTRL0_SWAPW_POS) 3863: | (ctrl0->swaph << AG903_PGPVIn_CTRL0_SWAPH_POS) 3864: | (ctrl0->swap4 << AG903_PGPVIn_CTRL0_SWAP4_POS) 3865: | (ctrl0->swap1 << AG903_PGPVIn_CTRL0_SWAP1_POS) 3866: | (ctrl0->md << AG903_PGPVIn_CTRL0_MD_POS) 3867: | (ctrl0->fmt << AG903_PGPVIn_CTRL0_FMT_POS); 3868: 3869: AG903_PGPVIn(id)->CTRL0 = val; 3870: } 3871: 3872: 3873: 3880: void AG903_PgpPrmGetPGPVInCTRL0(uint32_t id, PGPPrmParamPGPVInCTRL0 *ctrl0) 3881: { 3882: uint32_t val; 3883: 3884: ASSERT(id < AG903_PGP_PRM_MAX_VRAMI); 3885: ASSERT(ctrl0 != NULL); 3886: 3887: val = AG903_PGPVIn(id)->CTRL0; 3888: 3889: ctrl0->fai = (val & AG903_PGPVIn_CTRL0_FAI_MSK) >> AG903_PGPVIn_CTRL0_FAI_POS; 3890: ctrl0->bmu = (val & AG903_PGPVIn_CTRL0_BMU_MSK) >> AG903_PGPVIn_CTRL0_BMU_POS; 3891: ctrl0->scan = (val & AG903_PGPVIn_CTRL0_SCAN_MSK) >> AG903_PGPVIn_CTRL0_SCAN_POS; 3892: ctrl0->dim = (val & AG903_PGPVIn_CTRL0_DIM_MSK) >> AG903_PGPVIn_CTRL0_DIM_POS; 3893: ctrl0->swapw = (val & AG903_PGPVIn_CTRL0_SWAPW_MSK) >> AG903_PGPVIn_CTRL0_SWAPW_POS; 3894: ctrl0->swaph = (val & AG903_PGPVIn_CTRL0_SWAPH_MSK) >> AG903_PGPVIn_CTRL0_SWAPH_POS; 3895: ctrl0->swap4 = (val & AG903_PGPVIn_CTRL0_SWAP4_MSK) >> AG903_PGPVIn_CTRL0_SWAP4_POS; 3896: ctrl0->swap1 = (val & AG903_PGPVIn_CTRL0_SWAP1_MSK) >> AG903_PGPVIn_CTRL0_SWAP1_POS; 3897: ctrl0->md = (val & AG903_PGPVIn_CTRL0_MD_MSK) >> AG903_PGPVIn_CTRL0_MD_POS; 3898: ctrl0->fmt = (val & AG903_PGPVIn_CTRL0_FMT_MSK) >> AG903_PGPVIn_CTRL0_FMT_POS; 3899: } 3900: 3901: 3902: 3911: void AG903_PgpPrmSetPGPVInCTRL1(uint32_t id, uint32_t div, uint32_t vld, uint32_t inv) 3912: { 3913: uint32_t val; 3914: 3915: ASSERT(id < AG903_PGP_PRM_MAX_VRAMI); 3916: ASSERT(!(div & ~(0xFF))); 3917: ASSERT(!(vld & ~(0xF))); 3918: ASSERT(!(inv & ~(0xF))); 3919: 3920: val = (div << AG903_PGPVIn_CTRL1_DIV_POS) 3921: | (vld << AG903_PGPVIn_CTRL1_VLD_POS) 3922: | (inv << AG903_PGPVIn_CTRL1_INV_POS); 3923: 3924: AG903_PGPVIn(id)->CTRL1 = val; 3925: } 3926: 3927: 3928: 3937: void AG903_PgpPrmGetPGPVInCTRL1(uint32_t id, uint32_t *div, uint32_t *vld, uint32_t *inv) 3938: { 3939: uint32_t val; 3940: 3941: ASSERT(id < AG903_PGP_PRM_MAX_VRAMI); 3942: ASSERT(div != NULL); 3943: ASSERT(vld != NULL); 3944: ASSERT(inv != NULL); 3945: 3946: val = AG903_PGPVIn(id)->CTRL1; 3947: 3948: *div = (val & AG903_PGPVIn_CTRL1_DIV_MSK) >> AG903_PGPVIn_CTRL1_DIV_POS; 3949: *vld = (val & AG903_PGPVIn_CTRL1_VLD_MSK) >> AG903_PGPVIn_CTRL1_VLD_POS; 3950: *inv = (val & AG903_PGPVIn_CTRL1_INV_MSK) >> AG903_PGPVIn_CTRL1_INV_POS; 3951: } 3952: 3953: 3954: 3961: void AG903_PgpPrmSetPGPVInBASE(uint32_t id, uint32_t adr) 3962: { 3963: uint32_t val; 3964: 3965: ASSERT(id < AG903_PGP_PRM_MAX_VRAMI); 3966: ASSERT(!(adr & ~(0x1FFFFFFF))); 3967: 3968: val = (adr << AG903_PGPVIn_BASE_ADR_POS); 3969: 3970: AG903_PGPVIn(id)->BASE = val; 3971: } 3972: 3973: 3974: 3981: void AG903_PgpPrmGetPGPVInBASE(uint32_t id, uint32_t *adr) 3982: { 3983: uint32_t val; 3984: 3985: ASSERT(id < AG903_PGP_PRM_MAX_VRAMI); 3986: ASSERT(adr != NULL); 3987: 3988: val = AG903_PGPVIn(id)->BASE; 3989: 3990: *adr = (val & AG903_PGPVIn_BASE_ADR_MSK) >> AG903_PGPVIn_BASE_ADR_POS; 3991: } 3992: 3993: 3994: 4001: void AG903_PgpPrmSetPGPVInHSIZE(uint32_t id, uint32_t hsize) 4002: { 4003: uint32_t val; 4004: 4005: ASSERT(id < AG903_PGP_PRM_MAX_VRAMI); 4006: ASSERT(!(hsize & ~(0x3FFF))); 4007: 4008: val = (hsize << AG903_PGPVIn_HSIZE_HSIZE_POS); 4009: 4010: AG903_PGPVIn(id)->HSIZE = val; 4011: } 4012: 4013: 4014: 4021: void AG903_PgpPrmGetPGPVInHSIZE(uint32_t id, uint32_t *hsize) 4022: { 4023: uint32_t val; 4024: 4025: ASSERT(id < AG903_PGP_PRM_MAX_VRAMI); 4026: ASSERT(hsize != NULL); 4027: 4028: val = AG903_PGPVIn(id)->HSIZE; 4029: 4030: *hsize = (val & AG903_PGPVIn_HSIZE_HSIZE_MSK) >> AG903_PGPVIn_HSIZE_HSIZE_POS; 4031: } 4032: 4033: 4034: 4041: void AG903_PgpPrmSetPGPVInHPRM0(uint32_t id, uint32_t hpw) 4042: { 4043: uint32_t val; 4044: 4045: ASSERT(id < AG903_PGP_PRM_MAX_VRAMI); 4046: ASSERT(!(hpw & ~(0xFFF))); 4047: 4048: val = (hpw << AG903_PGPVIn_HPRM0_HPW_POS); 4049: 4050: AG903_PGPVIn(id)->HPRM0 = val; 4051: } 4052: 4053: 4054: 4061: void AG903_PgpPrmGetPGPVInHPRM0(uint32_t id, uint32_t *hpw) 4062: { 4063: uint32_t val; 4064: 4065: ASSERT(id < AG903_PGP_PRM_MAX_VRAMI); 4066: ASSERT(hpw != NULL); 4067: 4068: val = AG903_PGPVIn(id)->HPRM0; 4069: 4070: *hpw = (val & AG903_PGPVIn_HPRM0_HPW_MSK) >> AG903_PGPVIn_HPRM0_HPW_POS; 4071: } 4072: 4073: 4074: 4082: void AG903_PgpPrmSetPGPVInHPRM1(uint32_t id, uint32_t hfp, uint32_t hbp) 4083: { 4084: uint32_t val; 4085: 4086: ASSERT(id < AG903_PGP_PRM_MAX_VRAMI); 4087: ASSERT(!(hfp & ~(0xFFF))); 4088: ASSERT(!(hbp & ~(0xFFF))); 4089: 4090: val = (hfp << AG903_PGPVIn_HPRM1_HFP_POS) 4091: | (hbp << AG903_PGPVIn_HPRM1_HBP_POS); 4092: 4093: AG903_PGPVIn(id)->HPRM1 = val; 4094: } 4095: 4096: 4097: 4105: void AG903_PgpPrmGetPGPVInHPRM1(uint32_t id, uint32_t *hfp, uint32_t *hbp) 4106: { 4107: uint32_t val; 4108: 4109: ASSERT(id < AG903_PGP_PRM_MAX_VRAMI); 4110: ASSERT(hfp != NULL); 4111: ASSERT(hbp != NULL); 4112: 4113: val = AG903_PGPVIn(id)->HPRM1; 4114: 4115: *hfp = (val & AG903_PGPVIn_HPRM1_HFP_MSK) >> AG903_PGPVIn_HPRM1_HFP_POS; 4116: *hbp = (val & AG903_PGPVIn_HPRM1_HBP_MSK) >> AG903_PGPVIn_HPRM1_HBP_POS; 4117: } 4118: 4119: 4120: 4127: void AG903_PgpPrmSetPGPVInVPRM0(uint32_t id, PGPPrmParamPGPVInVPRM0 *vprm0) 4128: { 4129: uint32_t val; 4130: 4131: ASSERT(id < AG903_PGP_PRM_MAX_VRAMI); 4132: ASSERT(vprm0 != NULL); 4133: ASSERT(!(vprm0->ebp & ~(0x1))); 4134: ASSERT(!(vprm0->efp & ~(0x1))); 4135: ASSERT(!(vprm0->obp & ~(0x1))); 4136: ASSERT(!(vprm0->ofp & ~(0x1))); 4137: ASSERT(!(vprm0->vpw & ~(0xFFF))); 4138: 4139: val = (vprm0->ebp << AG903_PGPVIn_VPRM0_EBP_POS) 4140: | (vprm0->efp << AG903_PGPVIn_VPRM0_EFP_POS) 4141: | (vprm0->obp << AG903_PGPVIn_VPRM0_OBP_POS) 4142: | (vprm0->ofp << AG903_PGPVIn_VPRM0_OFP_POS) 4143: | (vprm0->vpw << AG903_PGPVIn_VPRM0_VPW_POS); 4144: 4145: AG903_PGPVIn(id)->VPRM0 = val; 4146: } 4147: 4148: 4149: 4156: void AG903_PgpPrmGetPGPVInVPRM0(uint32_t id, PGPPrmParamPGPVInVPRM0 *vprm0) 4157: { 4158: uint32_t val; 4159: 4160: ASSERT(id < AG903_PGP_PRM_MAX_VRAMI); 4161: ASSERT(vprm0 != NULL); 4162: 4163: val = AG903_PGPVIn(id)->VPRM0; 4164: 4165: vprm0->ebp = (val & AG903_PGPVIn_VPRM0_EBP_MSK) >> AG903_PGPVIn_VPRM0_EBP_POS; 4166: vprm0->efp = (val & AG903_PGPVIn_VPRM0_EFP_MSK) >> AG903_PGPVIn_VPRM0_EFP_POS; 4167: vprm0->obp = (val & AG903_PGPVIn_VPRM0_OBP_MSK) >> AG903_PGPVIn_VPRM0_OBP_POS; 4168: vprm0->ofp = (val & AG903_PGPVIn_VPRM0_OFP_MSK) >> AG903_PGPVIn_VPRM0_OFP_POS; 4169: vprm0->vpw = (val & AG903_PGPVIn_VPRM0_VPW_MSK) >> AG903_PGPVIn_VPRM0_VPW_POS; 4170: } 4171: 4172: 4173: 4181: void AG903_PgpPrmSetPGPVInVPRM1(uint32_t id, uint32_t vfp, uint32_t vbp) 4182: { 4183: uint32_t val; 4184: 4185: ASSERT(id < AG903_PGP_PRM_MAX_VRAMI); 4186: ASSERT(!(vfp & ~(0xFFF))); 4187: ASSERT(!(vbp & ~(0xFFF))); 4188: 4189: val = (vfp << AG903_PGPVIn_VPRM1_VFP_POS) 4190: | (vbp << AG903_PGPVIn_VPRM1_VBP_POS); 4191: 4192: AG903_PGPVIn(id)->VPRM1 = val; 4193: } 4194: 4195: 4196: 4204: void AG903_PgpPrmGetPGPVInVPRM1(uint32_t id, uint32_t *vfp, uint32_t *vbp) 4205: { 4206: uint32_t val; 4207: 4208: ASSERT(id < AG903_PGP_PRM_MAX_VRAMI); 4209: ASSERT(vfp != NULL); 4210: ASSERT(vbp != NULL); 4211: 4212: val = AG903_PGPVIn(id)->VPRM1; 4213: 4214: *vfp = (val & AG903_PGPVIn_VPRM1_VFP_MSK) >> AG903_PGPVIn_VPRM1_VFP_POS; 4215: *vbp = (val & AG903_PGPVIn_VPRM1_VBP_MSK) >> AG903_PGPVIn_VPRM1_VBP_POS; 4216: } 4217: 4218: 4219: 4228: void AG903_PgpPrmSetPGPVInSIZE(uint32_t id, uint32_t ovsize, uint32_t vsize, uint32_t hsize) 4229: { 4230: uint32_t val; 4231: 4232: ASSERT(id < AG903_PGP_PRM_MAX_VRAMI); 4233: ASSERT(!(ovsize & ~(0x1))); 4234: ASSERT(!(vsize & ~(0xFFF))); 4235: ASSERT(!(hsize & ~(0xFFF))); 4236: 4237: val = (ovsize << AG903_PGPVIn_SIZE_OVSIZE_POS) 4238: | (vsize << AG903_PGPVIn_SIZE_VSIZE_POS) 4239: | (hsize << AG903_PGPVIn_SIZE_HSIZE_POS); 4240: 4241: AG903_PGPVIn(id)->SIZE = val; 4242: } 4243: 4244: 4245: 4254: void AG903_PgpPrmGetPGPVInSIZE(uint32_t id, uint32_t *ovsize, uint32_t *vsize, uint32_t *hsize) 4255: { 4256: uint32_t val; 4257: 4258: ASSERT(id < AG903_PGP_PRM_MAX_VRAMI); 4259: ASSERT(ovsize != NULL); 4260: ASSERT(vsize != NULL); 4261: ASSERT(hsize != NULL); 4262: 4263: val = AG903_PGPVIn(id)->SIZE; 4264: 4265: *ovsize = (val & AG903_PGPVIn_SIZE_OVSIZE_MSK) >> AG903_PGPVIn_SIZE_OVSIZE_POS; 4266: *vsize = (val & AG903_PGPVIn_SIZE_VSIZE_MSK) >> AG903_PGPVIn_SIZE_VSIZE_POS; 4267: *hsize = (val & AG903_PGPVIn_SIZE_HSIZE_MSK) >> AG903_PGPVIn_SIZE_HSIZE_POS; 4268: } 4269: 4270: 4271: 4278: void AG903_PgpPrmSetPGPnDGCLUTB(uint32_t id, uint8_t blue[256]) 4279: { 4280: volatile AG903_PGP0DGC_Type *dgc; 4281: uint32_t val; 4282: uint32_t i; 4283: 4284: ASSERT(id < AG903_PGP_PRM_MAX_DGCLUT); 4285: ASSERT(blue != NULL); 4286: 4287: dgc = AG903_PGPnDGC(id); 4288: 4289: for (i = 0; i < 64; i++) { 4290: val = (blue[i * 4 + 0] << AG903_PGP0DGC_LUTB_B0_POS) | 4291: (blue[i * 4 + 1] << AG903_PGP0DGC_LUTB_B1_POS) | 4292: (blue[i * 4 + 2] << AG903_PGP0DGC_LUTB_B2_POS) | 4293: (blue[i * 4 + 3] << AG903_PGP0DGC_LUTB_B3_POS); 4294: dgc->LUTB[i] = val; 4295: } 4296: } 4297: 4298: 4299: 4306: void AG903_PgpPrmGetPGPnDGCLUTB(uint32_t id, uint8_t *blue) 4307: { 4308: volatile AG903_PGP0DGC_Type *dgc; 4309: uint32_t val; 4310: int32_t i; 4311: 4312: ASSERT(id < AG903_PGP_PRM_MAX_DGCLUT); 4313: ASSERT(blue != NULL); 4314: 4315: dgc = AG903_PGPnDGC(id); 4316: 4317: for (i = 0; i < 64; i++) { 4318: val = dgc->LUTB[i]; 4319: blue[i * 4 + 0] = (val & AG903_PGP0DGC_LUTB_B0_MSK) >> AG903_PGP0DGC_LUTB_B0_POS; 4320: blue[i * 4 + 1] = (val & AG903_PGP0DGC_LUTB_B1_MSK) >> AG903_PGP0DGC_LUTB_B1_POS; 4321: blue[i * 4 + 2] = (val & AG903_PGP0DGC_LUTB_B2_MSK) >> AG903_PGP0DGC_LUTB_B2_POS; 4322: blue[i * 4 + 3] = (val & AG903_PGP0DGC_LUTB_B3_MSK) >> AG903_PGP0DGC_LUTB_B3_POS; 4323: } 4324: } 4325: 4326: 4333: void AG903_PgpPrmSetPGPnDGCFLUTB(uint32_t id, uint8_t blue[256]) 4334: { 4335: volatile AG903_PGP0DGCF_Type *dgc; 4336: uint32_t val; 4337: uint32_t i; 4338: 4339: ASSERT(id < AG903_PGP_PRM_MAX_DGCLUT); 4340: ASSERT(blue != NULL); 4341: 4342: dgc = AG903_PGPnDGCF(id); 4343: 4344: 4345: for (i = 0; i < 64; i++) { 4346: while (1) { 4347: AG903_PgpPrmGetPGPnDGCSTAT(id, &val); 4348: 4349: if (val > 0) { 4350: break; 4351: } 4352: } 4353: val = (blue[i * 4 + 0] << AG903_PGP0DGC_LUTB_B0_POS) | 4354: (blue[i * 4 + 1] << AG903_PGP0DGC_LUTB_B1_POS) | 4355: (blue[i * 4 + 2] << AG903_PGP0DGC_LUTB_B2_POS) | 4356: (blue[i * 4 + 3] << AG903_PGP0DGC_LUTB_B3_POS); 4357: dgc->LUTB[i] = val; 4358: } 4359: } 4360: 4361: 4368: void AG903_PgpPrmSetPGPnDGCLUTG(uint32_t id, uint8_t green[256]) 4369: { 4370: volatile AG903_PGP0DGC_Type *dgc; 4371: uint32_t val; 4372: uint32_t i; 4373: 4374: ASSERT(id < AG903_PGP_PRM_MAX_DGCLUT); 4375: ASSERT(green != NULL); 4376: 4377: dgc = AG903_PGPnDGC(id); 4378: 4379: for (i = 0; i < 64; i++) { 4380: val = (green[i * 4 + 0] << AG903_PGP0DGC_LUTG_G0_POS) | 4381: (green[i * 4 + 1] << AG903_PGP0DGC_LUTG_G1_POS) | 4382: (green[i * 4 + 2] << AG903_PGP0DGC_LUTG_G2_POS) | 4383: (green[i * 4 + 3] << AG903_PGP0DGC_LUTG_G3_POS); 4384: dgc->LUTG[i] = val; 4385: } 4386: } 4387: 4388: 4389: 4396: void AG903_PgpPrmGetPGPnDGCLUTG(uint32_t id, uint8_t *green) 4397: { 4398: volatile AG903_PGP0DGC_Type *dgc; 4399: uint32_t val; 4400: int32_t i; 4401: 4402: ASSERT(id < AG903_PGP_PRM_MAX_DGCLUT); 4403: ASSERT(green != NULL); 4404: 4405: dgc = AG903_PGPnDGC(id); 4406: 4407: for (i = 0; i < 64; i++) { 4408: val = dgc->LUTG[i]; 4409: green[i * 4 + 0] = (val & AG903_PGP0DGC_LUTG_G0_MSK) >> AG903_PGP0DGC_LUTG_G0_POS; 4410: green[i * 4 + 1] = (val & AG903_PGP0DGC_LUTG_G1_MSK) >> AG903_PGP0DGC_LUTG_G1_POS; 4411: green[i * 4 + 2] = (val & AG903_PGP0DGC_LUTG_G2_MSK) >> AG903_PGP0DGC_LUTG_G2_POS; 4412: green[i * 4 + 3] = (val & AG903_PGP0DGC_LUTG_G3_MSK) >> AG903_PGP0DGC_LUTG_G3_POS; 4413: } 4414: } 4415: 4416: 4417: 4424: void AG903_PgpPrmSetPGPnDGCFLUTG(uint32_t id, uint8_t green[256]) 4425: { 4426: volatile AG903_PGP0DGCF_Type *dgc; 4427: uint32_t val; 4428: uint32_t i; 4429: 4430: ASSERT(id < AG903_PGP_PRM_MAX_DGCLUT); 4431: ASSERT(green != NULL); 4432: 4433: dgc = AG903_PGPnDGCF(id); 4434: 4435: 4436: for (i = 0; i < 64; i++) { 4437: while (1) { 4438: AG903_PgpPrmGetPGPnDGCSTAT(id, &val); 4439: 4440: if (val > 0) { 4441: break; 4442: } 4443: } 4444: val = (green[i * 4 + 0] << AG903_PGP0DGC_LUTG_G0_POS) | 4445: (green[i * 4 + 1] << AG903_PGP0DGC_LUTG_G1_POS) | 4446: (green[i * 4 + 2] << AG903_PGP0DGC_LUTG_G2_POS) | 4447: (green[i * 4 + 3] << AG903_PGP0DGC_LUTG_G3_POS); 4448: dgc->LUTG[i] = val; 4449: } 4450: } 4451: 4452: 4453: 4460: void AG903_PgpPrmSetPGPnDGCLUTR(uint32_t id, uint8_t red[256]) 4461: { 4462: volatile AG903_PGP0DGC_Type *dgc; 4463: uint32_t val; 4464: uint32_t i; 4465: 4466: ASSERT(id < AG903_PGP_PRM_MAX_DGCLUT); 4467: ASSERT(red != NULL); 4468: 4469: dgc = AG903_PGPnDGC(id); 4470: 4471: for (i = 0; i < 64; i++) { 4472: val = (red[i * 4 + 0] << AG903_PGP0DGC_LUTR_R0_POS) | 4473: (red[i * 4 + 1] << AG903_PGP0DGC_LUTR_R1_POS) | 4474: (red[i * 4 + 2] << AG903_PGP0DGC_LUTR_R2_POS) | 4475: (red[i * 4 + 3] << AG903_PGP0DGC_LUTR_R3_POS); 4476: dgc->LUTR[i] = val; 4477: } 4478: } 4479: 4480: 4481: 4488: void AG903_PgpPrmGetPGPnDGCLUTR(uint32_t id, uint8_t *red) 4489: { 4490: volatile AG903_PGP0DGC_Type *dgc; 4491: uint32_t val; 4492: int32_t i; 4493: 4494: ASSERT(id < AG903_PGP_PRM_MAX_DGCLUT); 4495: ASSERT(red != NULL); 4496: 4497: dgc = AG903_PGPnDGC(id); 4498: 4499: for (i = 0; i < 64; i++) { 4500: val = dgc->LUTR[i]; 4501: red[i * 4 + 0] = (val & AG903_PGP0DGC_LUTR_R0_MSK) >> AG903_PGP0DGC_LUTR_R0_POS; 4502: red[i * 4 + 1] = (val & AG903_PGP0DGC_LUTR_R1_MSK) >> AG903_PGP0DGC_LUTR_R1_POS; 4503: red[i * 4 + 2] = (val & AG903_PGP0DGC_LUTR_R2_MSK) >> AG903_PGP0DGC_LUTR_R2_POS; 4504: red[i * 4 + 3] = (val & AG903_PGP0DGC_LUTR_R3_MSK) >> AG903_PGP0DGC_LUTR_R3_POS; 4505: } 4506: } 4507: 4508: 4515: void AG903_PgpPrmSetPGPnDGCFLUTR(uint32_t id, uint8_t red[256]) 4516: { 4517: volatile AG903_PGP0DGCF_Type *dgc; 4518: uint32_t val; 4519: uint32_t i; 4520: 4521: ASSERT(id < AG903_PGP_PRM_MAX_DGCLUT); 4522: ASSERT(red != NULL); 4523: 4524: dgc = AG903_PGPnDGCF(id); 4525: 4526: 4527: for (i = 0; i < 64; i++) { 4528: while (1) { 4529: AG903_PgpPrmGetPGPnDGCSTAT(id, &val); 4530: 4531: if (val > 0) { 4532: break; 4533: } 4534: } 4535: val = (red[i * 4 + 0] << AG903_PGP0DGC_LUTR_R0_POS) | 4536: (red[i * 4 + 1] << AG903_PGP0DGC_LUTR_R1_POS) | 4537: (red[i * 4 + 2] << AG903_PGP0DGC_LUTR_R2_POS) | 4538: (red[i * 4 + 3] << AG903_PGP0DGC_LUTR_R3_POS); 4539: dgc->LUTR[i] = val; 4540: } 4541: }
Copyright (c) 2017-2025 Axell Corporation. All rights reserved.