AG903ライブラリリファレンス
内容インデックスホーム
前へ上へ次へ
pgpprm.c

PGP Primitive

PGP Primitive Layer.

none

AXELL CORPORATION

2017_02_22 初版 

2017_10_26 Ver2.0

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: }
 
名前 
説明 
 
PGPJPGOUTSELレジスタ取得 
 
PGPnCSC1CTRLレジスタ取得 
 
PGPnCSC1PRM0レジスタ取得 
 
PGPnCSC1PRM1レジスタ取得 
 
PGPnCSC1PRM2レジスタ取得 
 
PGPnCSC1PRM3レジスタ取得 
 
PGPnCSC1PRM4レジスタ取得 
 
PGPnCSC1PRM5レジスタ取得 
 
PGPnCSC1PRM6レジスタ取得 
 
PGPnCSC1PRM7レジスタ取得 
 
PGPnCSC1PRM8レジスタ取得 
 
PGPnCSC2CTRLレジスタ取得 
 
PGPnCSC2PRM0レジスタ取得 
 
PGPnCSC2PRM1レジスタ取得 
 
PGPnCSC2PRM2レジスタ取得 
 
PGPnCSC2PRM3レジスタ取得 
 
PGPnCSC2PRM4レジスタ取得 
 
PGPnCSC2PRM5レジスタ取得 
 
PGPnCSC2PRM6レジスタ取得 
 
PGPnCSC2PRM7レジスタ取得 
 
PGPnCSC2PRM8レジスタ取得 
 
PGPnDGCLUTBmレジスタ取得 
 
PGPnDGCLUTGmレジスタ取得
PGPnDGCLUTGmレジスタ取得 
 
PGPnDGCLUTRmレジスタ取得
PGPnDGCLUTRmレジスタ取得 
 
PGPnDGCSTATLレジスタ取得 
 
PGPnFAIVAL0レジスタ取得 
 
PGPnFAIVAL1レジスタ取得 
 
PGPnFUNCCTRLレジスタ取得 
 
PGPnHGMCTRLレジスタ取得 
 
PGPnHGMDSTレジスタ取得 
 
PGPnHGMMOD0レジスタ取得 
 
PGPnHGMMOD1レジスタ取得 
 
PGPnHGMMOD2レジスタ取得 
 
PGPnHGMPOSレジスタ取得 
 
PGPnHGMRNG0レジスタ取得 
 
PGPnHGMRNG1レジスタ取得 
 
PGPnHGMRNG2レジスタ取得 
 
PGPnHGMSIZEレジスタ取得 
 
PGPnHGMSTATレジスタ取得 
 
PGPnHSV1CTRLレジスタ取得 
 
PGPnHSV2CTRLレジスタ取得 
 
PGPnIFCCTRLレジスタ取得 
 
PGPnIFCPRMレジスタ取得 
 
PGPnINCTRLレジスタ取得 
 
PGPnINTCTRLIレジスタ取得 
 
PGPnINTCTRLOレジスタ取得 
 
PGPnINTENレジスタ取得 
 
PGPnINTSTATレジスタ取得 
 
PGPnIPCPRMレジスタ取得 
 
PGPnLBLCTRLレジスタ取得 
 
PGPnLBLDSTレジスタ取得 
 
PGPnLBLPOSレジスタ取得 
 
PGPnLBLSIZEレジスタ取得 
 
PGPnLBLSTATレジスタ取得 
 
PGPnMSK0PRM0レジスタ取得 
 
PGPnMSK0PRM1レジスタ取得 
 
PGPnMSK1PRM0レジスタ取得 
 
PGPnMSK1PRM1レジスタ取得 
 
PGPnMSK2PRM0レジスタ取得 
 
PGPnMSK2PRM1レジスタ取得 
 
PGPnOUTBASEレジスタ取得 
 
PGPnOUTCTRL0レジスタ取得 
 
PGPnOUTCTRL1レジスタ取得 
 
PGPnOUTHSIZEレジスタ取得 
 
PGPnPOSレジスタ取得 
 
PGPnSCCTRLレジスタ取得 
 
PGPnSIZEレジスタ取得 
 
PGPnSPF1PRM0レジスタ取得 
 
PGPnSPF1PRM1レジスタ取得 
 
PGPnSPFCTRLレジスタ取得 
 
PGPnSPFPRM0レジスタ取得 
 
PGPnSPFPRM1レジスタ取得 
 
PGPnSPFPRM2レジスタ取得 
 
PGPnSPFPRM3レジスタ取得 
 
PGPnSTATEレジスタ取得 
 
PGPnTHR1CNTレジスタ取得 
 
PGPnTHR1PRM0レジスタ取得 
 
PGPnTHR1PRM1レジスタ取得 
 
PGPnTHR8PRM0レジスタ取得 
 
PGPnTHR8PRM1レジスタ取得 
 
PGPnTHR8PRM2レジスタ取得 
 
PGPnTHRCTRLレジスタ取得 
 
PGPnTRGCTRLIレジスタ取得 
 
PGPnTRGCTRLOレジスタ取得 
 
PGPnTRGENレジスタ取得 
 
PGPVInBASEレジスタ取得 
 
PGPVInCTRL0レジスタ取得 
 
PGPVInCTRL1レジスタ取得 
 
PGPVInHPRM0レジスタ取得 
 
PGPVInHPRM1レジスタ取得 
 
PGPVInHSIZEレジスタ取得 
 
PGPVInSIZEレジスタ取得 
 
PGPVInSTATEレジスタ取得 
 
PGPVInVPRM0レジスタ取得 
 
PGPVInVPRM1レジスタ取得 
 
PGPJPGOUTSELレジスタ設定 
 
PGPnCMDレジスタ設定 
 
PGPnCSC1CTRLレジスタ設定 
 
PGPnCSC1PRM0レジスタ設定 
 
PGPnCSC1PRM1レジスタ設定 
 
PGPnCSC1PRM2レジスタ設定 
 
PGPnCSC1PRM3レジスタ設定 
 
PGPnCSC1PRM4レジスタ設定 
 
PGPnCSC1PRM5レジスタ設定 
 
PGPnCSC1PRM6レジスタ設定 
 
PGPnCSC1PRM7レジスタ設定 
 
PGPnCSC1PRM8レジスタ設定 
 
PGPnCSC2CTRLレジスタ設定 
 
PGPnCSC2PRM0レジスタ設定 
 
PGPnCSC2PRM1レジスタ設定 
 
PGPnCSC2PRM2レジスタ設定 
 
PGPnCSC2PRM3レジスタ設定 
 
PGPnCSC2PRM4レジスタ設定 
 
PGPnCSC2PRM5レジスタ設定 
 
PGPnCSC2PRM6レジスタ設定 
 
PGPnCSC2PRM7レジスタ設定 
 
PGPnCSC2PRM8レジスタ設定 
 
PGPnDGCFLUTBmレジスタ設定
PGPnDGCFLUTBmレジスタ設定 
 
PGPnDGCFLUTGmレジスタ設定
PGPnDGCFLUTGmレジスタ設定 
 
PGPnDGCFLUTRmレジスタ設定
PGPnDGCFLUTRmレジスタ設定 
 
PGPnDGCLUTBmレジスタ設定 
 
PGPnDGCLUTGmレジスタ設定
PGPnDGCLUTGmレジスタ設定 
 
PGPnDGCLUTRmレジスタ設定
PGPnDGCLUTRmレジスタ設定 
 
PGPnFUNCCTRLレジスタ設定 
 
PGPnHGMCMDレジスタ設定 
 
PGPnHGMCTRLレジスタ設定 
 
PGPnHGMDSTレジスタ設定 
 
PGPnHGMPOSレジスタ設定 
 
PGPnHGMSIZEレジスタ設定 
 
PGPnHSV1CTRLレジスタ設定 
 
PGPnHSV2CTRLレジスタ設定 
 
PGPnIFCCMDレジスタ設定 
 
PGPnIFCCTRLレジスタ設定 
 
PGPnIFCPRMレジスタ設定 
 
PGPnINCTRLレジスタ設定 
 
PGPnINTCLRレジスタ設定 
 
PGPnINTCTRLIレジスタ設定 
 
PGPnINTCTRLOレジスタ設定 
 
PGPnINTENレジスタ設定 
 
PGPnIPCPRMレジスタ設定 
 
PGPnLBLCMDレジスタ設定 
 
PGPnLBLCTRLレジスタ設定 
 
PGPnLBLDSTレジスタ設定 
 
PGPnLBLPOSレジスタ設定 
 
PGPnLBLSIZEレジスタ設定 
 
PGPnMSK0PRM0レジスタ設定 
 
PGPnMSK0PRM1レジスタ設定 
 
PGPnMSK1PRM0レジスタ設定 
 
PGPnMSK1PRM1レジスタ設定 
 
PGPnMSK2PRM0レジスタ設定 
 
PGPnMSK2PRM1レジスタ設定 
 
PGPnOUTBASEレジスタ設定 
 
PGPnOUTCTRL0レジスタ設定 
 
PGPnOUTCTRL1レジスタ設定 
 
PGPnOUTHSIZEレジスタ設定 
 
PGPnPOSレジスタ設定 
 
PGPnSCCTRLレジスタ設定 
 
PGPnSIZEレジスタ設定 
 
PGPnSPF1PRM0レジスタ設定 
 
PGPnSPF1PRM1レジスタ設定 
 
PGPnSPFCTRLレジスタ設定 
 
PGPnSPFPRM0レジスタ設定 
 
PGPnSPFPRM1レジスタ設定 
 
PGPnSPFPRM2レジスタ設定 
 
PGPnSPFPRM3レジスタ設定 
 
PGPnTHR1PRM0レジスタ設定 
 
PGPnTHR1PRM1レジスタ設定 
 
PGPnTHR8PRM0レジスタ設定 
 
PGPnTHR8PRM1レジスタ設定 
 
PGPnTHR8PRM2レジスタ設定 
 
PGPnTHRCTRLレジスタ設定 
 
PGPnTRGCTRLIレジスタ設定 
 
PGPnTRGCTRLOレジスタ設定 
 
PGPnTRGENレジスタ設定 
 
PGPVInBASEレジスタ設定 
 
PGPVInCMDレジスタ設定 
 
PGPVInCTRL0レジスタ設定 
 
PGPVInCTRL1レジスタ設定 
 
PGPVInHPRM0レジスタ設定 
 
PGPVInHPRM1レジスタ設定 
 
PGPVInHSIZEレジスタ設定 
 
PGPVInSIZEレジスタ設定 
 
PGPVInVPRM0レジスタ設定 
 
PGPVInVPRM1レジスタ設定 
Copyright (c) 2017-2025 Axell Corporation. All rights reserved.