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: }