1 // Copyright (C) 2022 Beken Corporation
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 /***********************************************************************************************************************************
16 * This file is generated from BK7256_ADDR_Mapping_MP2.xlsm automatically
17 * Modify it manually is not recommended
18 * CHIP ID:BK7256,GENARATE TIME:2022-07-16 15:30:25
19 ************************************************************************************************************************************/
20
21 #pragma once
22
23 #ifdef __cplusplus
24 extern "C" {
25 #endif
26
27 #include <soc/soc.h>
28
29 #define JPEG_DEC_LL_REG_BASE (SOC_JPEG_DEC_REG_BASE) //REG_BASE:0x48040000
30
31 /* REG_0x00 */
32 #define JPEG_DEC_REG0X0_ADDR (JPEG_DEC_LL_REG_BASE + 0x0*4) //REG ADDR :0x48040000
33 #define JPEG_DEC_REG0X0_JPEG_DEC_EN_POS (0)
34 #define JPEG_DEC_REG0X0_JPEG_DEC_EN_MASK (0x3)
35
36 #define JPEG_DEC_REG0X0_RESERVED_POS (2)
37 #define JPEG_DEC_REG0X0_RESERVED_MASK (0x7FFFFFF)
38
39 #define JPEG_DEC_REG0X0_DRI_BPS_POS (29)
40 #define JPEG_DEC_REG0X0_DRI_BPS_MASK (0x1)
41
42 #define JPEG_DEC_REG0X0_YY_VLD_BPS_POS (30)
43 #define JPEG_DEC_REG0X0_YY_VLD_BPS_MASK (0x1)
44
45 #define JPEG_DEC_REG0X0_SHARMEM_BPS_POS (31)
46 #define JPEG_DEC_REG0X0_SHARMEM_BPS_MASK (0x1)
47
jpeg_dec_ll_get_reg0x0_value(void)48 static inline uint32_t jpeg_dec_ll_get_reg0x0_value(void)
49 {
50 return REG_READ(JPEG_DEC_REG0X0_ADDR);
51 }
52
jpeg_dec_ll_set_reg0x0_value(uint32_t value)53 static inline void jpeg_dec_ll_set_reg0x0_value(uint32_t value)
54 {
55 REG_WRITE(JPEG_DEC_REG0X0_ADDR,value);
56 }
57
58 /* REG_0x00:reg0x0->jpeg_dec_en:0x0[1:0],jpeg dec enable,0x0,R/W*/
jpeg_dec_ll_get_reg0x0_jpeg_dec_en(void)59 static inline uint32_t jpeg_dec_ll_get_reg0x0_jpeg_dec_en(void)
60 {
61 uint32_t reg_value;
62 reg_value = REG_READ(JPEG_DEC_REG0X0_ADDR);
63 reg_value = ((reg_value >> JPEG_DEC_REG0X0_JPEG_DEC_EN_POS) & JPEG_DEC_REG0X0_JPEG_DEC_EN_MASK);
64 return reg_value;
65 }
66
jpeg_dec_ll_set_reg0x0_jpeg_dec_en(uint32_t value)67 static inline void jpeg_dec_ll_set_reg0x0_jpeg_dec_en(uint32_t value)
68 {
69 uint32_t reg_value;
70 reg_value = REG_READ(JPEG_DEC_REG0X0_ADDR);
71 reg_value &= ~(JPEG_DEC_REG0X0_JPEG_DEC_EN_MASK << JPEG_DEC_REG0X0_JPEG_DEC_EN_POS);
72 reg_value |= ((value & JPEG_DEC_REG0X0_JPEG_DEC_EN_MASK) << JPEG_DEC_REG0X0_JPEG_DEC_EN_POS);
73 REG_WRITE(JPEG_DEC_REG0X0_ADDR,reg_value);
74 }
75
76 /* REG_0x00:reg0x0->dri_bps:0x0[29],set 0,bypass dri support,0x0,R/W*/
jpeg_dec_ll_get_reg0x0_dri_bps(void)77 static inline uint32_t jpeg_dec_ll_get_reg0x0_dri_bps(void)
78 {
79 uint32_t reg_value;
80 reg_value = REG_READ(JPEG_DEC_REG0X0_ADDR);
81 reg_value = ((reg_value >> JPEG_DEC_REG0X0_DRI_BPS_POS) & JPEG_DEC_REG0X0_DRI_BPS_MASK);
82 return reg_value;
83 }
84
jpeg_dec_ll_set_reg0x0_dri_bps(uint32_t value)85 static inline void jpeg_dec_ll_set_reg0x0_dri_bps(uint32_t value)
86 {
87 uint32_t reg_value;
88 reg_value = REG_READ(JPEG_DEC_REG0X0_ADDR);
89 reg_value &= ~(JPEG_DEC_REG0X0_DRI_BPS_MASK << JPEG_DEC_REG0X0_DRI_BPS_POS);
90 reg_value |= ((value & JPEG_DEC_REG0X0_DRI_BPS_MASK) << JPEG_DEC_REG0X0_DRI_BPS_POS);
91 REG_WRITE(JPEG_DEC_REG0X0_ADDR,reg_value);
92 }
93
94 /* REG_0x00:reg0x0->yy_vld_bps:0x0[30],set 0,used for debug,0x0,R/W*/
jpeg_dec_ll_get_reg0x0_yy_vld_bps(void)95 static inline uint32_t jpeg_dec_ll_get_reg0x0_yy_vld_bps(void)
96 {
97 uint32_t reg_value;
98 reg_value = REG_READ(JPEG_DEC_REG0X0_ADDR);
99 reg_value = ((reg_value >> JPEG_DEC_REG0X0_YY_VLD_BPS_POS) & JPEG_DEC_REG0X0_YY_VLD_BPS_MASK);
100 return reg_value;
101 }
102
jpeg_dec_ll_set_reg0x0_yy_vld_bps(uint32_t value)103 static inline void jpeg_dec_ll_set_reg0x0_yy_vld_bps(uint32_t value)
104 {
105 uint32_t reg_value;
106 reg_value = REG_READ(JPEG_DEC_REG0X0_ADDR);
107 reg_value &= ~(JPEG_DEC_REG0X0_YY_VLD_BPS_MASK << JPEG_DEC_REG0X0_YY_VLD_BPS_POS);
108 reg_value |= ((value & JPEG_DEC_REG0X0_YY_VLD_BPS_MASK) << JPEG_DEC_REG0X0_YY_VLD_BPS_POS);
109 REG_WRITE(JPEG_DEC_REG0X0_ADDR,reg_value);
110 }
111
112 /* REG_0x00:reg0x0->sharmem_bps:0x0[31],set 0,used for debug,0x0,R/W*/
jpeg_dec_ll_get_reg0x0_sharmem_bps(void)113 static inline uint32_t jpeg_dec_ll_get_reg0x0_sharmem_bps(void)
114 {
115 uint32_t reg_value;
116 reg_value = REG_READ(JPEG_DEC_REG0X0_ADDR);
117 reg_value = ((reg_value >> JPEG_DEC_REG0X0_SHARMEM_BPS_POS) & JPEG_DEC_REG0X0_SHARMEM_BPS_MASK);
118 return reg_value;
119 }
120
jpeg_dec_ll_set_reg0x0_sharmem_bps(uint32_t value)121 static inline void jpeg_dec_ll_set_reg0x0_sharmem_bps(uint32_t value)
122 {
123 uint32_t reg_value;
124 reg_value = REG_READ(JPEG_DEC_REG0X0_ADDR);
125 reg_value &= ~(JPEG_DEC_REG0X0_SHARMEM_BPS_MASK << JPEG_DEC_REG0X0_SHARMEM_BPS_POS);
126 reg_value |= ((value & JPEG_DEC_REG0X0_SHARMEM_BPS_MASK) << JPEG_DEC_REG0X0_SHARMEM_BPS_POS);
127 REG_WRITE(JPEG_DEC_REG0X0_ADDR,reg_value);
128 }
129
130 /* REG_0x01 */
131 #define JPEG_DEC_REG0X1_ADDR (JPEG_DEC_LL_REG_BASE + 0x1*4) //REG ADDR :0x48040004
132 #define JPEG_DEC_REG0X1_MCU_INDEX_POS (0)
133 #define JPEG_DEC_REG0X1_MCU_INDEX_MASK (0xFFFF)
134
135 #define JPEG_DEC_REG0X1_MCU_Y_NUM_POS (16)
136 #define JPEG_DEC_REG0X1_MCU_Y_NUM_MASK (0x3FF)
137
138 #define JPEG_DEC_REG0X1_RESERVED_POS (26)
139 #define JPEG_DEC_REG0X1_RESERVED_MASK (0x3F)
140
jpeg_dec_ll_get_reg0x1_value(void)141 static inline uint32_t jpeg_dec_ll_get_reg0x1_value(void)
142 {
143 return REG_READ(JPEG_DEC_REG0X1_ADDR);
144 }
145
146
147
148 /* REG_0x01:reg0x1->mcu_index:0x1[15:0],mcu index,0x0,R/W*/
jpeg_dec_ll_get_reg0x1_mcu_index(void)149 static inline uint32_t jpeg_dec_ll_get_reg0x1_mcu_index(void)
150 {
151 uint32_t reg_value;
152 reg_value = REG_READ(JPEG_DEC_REG0X1_ADDR);
153 reg_value = ((reg_value >> JPEG_DEC_REG0X1_MCU_INDEX_POS) & JPEG_DEC_REG0X1_MCU_INDEX_MASK);
154 return reg_value;
155 }
156
157
158 /* REG_0x01:reg0x1->mcu_y_num:0x1[25:16],line number,0x0,R/W*/
jpeg_dec_ll_get_reg0x1_mcu_y_num(void)159 static inline uint32_t jpeg_dec_ll_get_reg0x1_mcu_y_num(void)
160 {
161 uint32_t reg_value;
162 reg_value = REG_READ(JPEG_DEC_REG0X1_ADDR);
163 reg_value = ((reg_value >> JPEG_DEC_REG0X1_MCU_Y_NUM_POS) & JPEG_DEC_REG0X1_MCU_Y_NUM_MASK);
164 return reg_value;
165 }
166
167
168 /* REG_0x02 */
169 #define JPEG_DEC_REG0X2_ADDR (JPEG_DEC_LL_REG_BASE + 0x2*4) //REG ADDR :0x48040008
170 #define JPEG_DEC_REG0X2_JPEG_DEC_AUTO_POS (0)
171 #define JPEG_DEC_REG0X2_JPEG_DEC_AUTO_MASK (0x1)
172
173 #define JPEG_DEC_REG0X2_JPEG_DEC_LINEN_POS (1)
174 #define JPEG_DEC_REG0X2_JPEG_DEC_LINEN_MASK (0x1)
175
176 #define JPEG_DEC_REG0X2_RESERVED2_POS (2)
177 #define JPEG_DEC_REG0X2_RESERVED2_MASK (0x3F)
178
179 #define JPEG_DEC_REG0X2_JPEG_LINE_NUM_POS (8)
180 #define JPEG_DEC_REG0X2_JPEG_LINE_NUM_MASK (0x1FFF)
181
182 #define JPEG_DEC_REG0X2_RESERVED_POS (21)
183 #define JPEG_DEC_REG0X2_RESERVED_MASK (0x7FF)
184
jpeg_dec_ll_get_reg0x2_value(void)185 static inline uint32_t jpeg_dec_ll_get_reg0x2_value(void)
186 {
187 return REG_READ(JPEG_DEC_REG0X2_ADDR);
188 }
189
jpeg_dec_ll_set_reg0x2_value(uint32_t value)190 static inline void jpeg_dec_ll_set_reg0x2_value(uint32_t value)
191 {
192 REG_WRITE(JPEG_DEC_REG0X2_ADDR,value);
193 }
194
195 /* REG_0x02:reg0x2->jpeg_dec_auto:0x2[0],auto jpeg dec,total decode,0x0,R/W*/
jpeg_dec_ll_get_reg0x2_jpeg_dec_auto(void)196 static inline uint32_t jpeg_dec_ll_get_reg0x2_jpeg_dec_auto(void)
197 {
198 uint32_t reg_value;
199 reg_value = REG_READ(JPEG_DEC_REG0X2_ADDR);
200 reg_value = ((reg_value >> JPEG_DEC_REG0X2_JPEG_DEC_AUTO_POS) & JPEG_DEC_REG0X2_JPEG_DEC_AUTO_MASK);
201 return reg_value;
202 }
203
jpeg_dec_ll_set_reg0x2_jpeg_dec_auto(uint32_t value)204 static inline void jpeg_dec_ll_set_reg0x2_jpeg_dec_auto(uint32_t value)
205 {
206 uint32_t reg_value;
207 reg_value = REG_READ(JPEG_DEC_REG0X2_ADDR);
208 reg_value &= ~(JPEG_DEC_REG0X2_JPEG_DEC_AUTO_MASK << JPEG_DEC_REG0X2_JPEG_DEC_AUTO_POS);
209 reg_value |= ((value & JPEG_DEC_REG0X2_JPEG_DEC_AUTO_MASK) << JPEG_DEC_REG0X2_JPEG_DEC_AUTO_POS);
210 REG_WRITE(JPEG_DEC_REG0X2_ADDR,reg_value);
211 }
212
213 /* REG_0x02:reg0x2->jpeg_dec_linen:0x2[1],auto jpeg dec,line decode,0x0,R/W*/
jpeg_dec_ll_get_reg0x2_jpeg_dec_linen(void)214 static inline uint32_t jpeg_dec_ll_get_reg0x2_jpeg_dec_linen(void)
215 {
216 uint32_t reg_value;
217 reg_value = REG_READ(JPEG_DEC_REG0X2_ADDR);
218 reg_value = ((reg_value >> JPEG_DEC_REG0X2_JPEG_DEC_LINEN_POS) & JPEG_DEC_REG0X2_JPEG_DEC_LINEN_MASK);
219 return reg_value;
220 }
221
jpeg_dec_ll_set_reg0x2_jpeg_dec_linen(uint32_t value)222 static inline void jpeg_dec_ll_set_reg0x2_jpeg_dec_linen(uint32_t value)
223 {
224 uint32_t reg_value;
225 reg_value = REG_READ(JPEG_DEC_REG0X2_ADDR);
226 reg_value &= ~(JPEG_DEC_REG0X2_JPEG_DEC_LINEN_MASK << JPEG_DEC_REG0X2_JPEG_DEC_LINEN_POS);
227 reg_value |= ((value & JPEG_DEC_REG0X2_JPEG_DEC_LINEN_MASK) << JPEG_DEC_REG0X2_JPEG_DEC_LINEN_POS);
228 REG_WRITE(JPEG_DEC_REG0X2_ADDR,reg_value);
229 }
230
231 /* REG_0x02:reg0x2->jpeg_line_num:0x2[20:8],when line decode, when(line==jpeg_line_num),generate interrupt,0x0,R/W*/
jpeg_dec_ll_get_reg0x2_jpeg_line_num(void)232 static inline uint32_t jpeg_dec_ll_get_reg0x2_jpeg_line_num(void)
233 {
234 uint32_t reg_value;
235 reg_value = REG_READ(JPEG_DEC_REG0X2_ADDR);
236 reg_value = ((reg_value >> JPEG_DEC_REG0X2_JPEG_LINE_NUM_POS) & JPEG_DEC_REG0X2_JPEG_LINE_NUM_MASK);
237 return reg_value;
238 }
239
jpeg_dec_ll_set_reg0x2_jpeg_line_num(uint32_t value)240 static inline void jpeg_dec_ll_set_reg0x2_jpeg_line_num(uint32_t value)
241 {
242 uint32_t reg_value;
243 reg_value = REG_READ(JPEG_DEC_REG0X2_ADDR);
244 reg_value &= ~(JPEG_DEC_REG0X2_JPEG_LINE_NUM_MASK << JPEG_DEC_REG0X2_JPEG_LINE_NUM_POS);
245 reg_value |= ((value & JPEG_DEC_REG0X2_JPEG_LINE_NUM_MASK) << JPEG_DEC_REG0X2_JPEG_LINE_NUM_POS);
246 REG_WRITE(JPEG_DEC_REG0X2_ADDR,reg_value);
247 }
248
249 /* REG_0x03 */
250 #define JPEG_DEC_REG0X3_ADDR (JPEG_DEC_LL_REG_BASE + 0x3*4) //REG ADDR :0x4804000c
251 #define JPEG_DEC_REG0X3_UV_VLD_POS (0)
252 #define JPEG_DEC_REG0X3_UV_VLD_MASK (0x1)
253
254 #define JPEG_DEC_REG0X3_RESERVED_POS (1)
255 #define JPEG_DEC_REG0X3_RESERVED_MASK (0x7FFFFFFF)
256
jpeg_dec_ll_get_reg0x3_value(void)257 static inline uint32_t jpeg_dec_ll_get_reg0x3_value(void)
258 {
259 return REG_READ(JPEG_DEC_REG0X3_ADDR);
260 }
261
jpeg_dec_ll_set_reg0x3_value(uint32_t value)262 static inline void jpeg_dec_ll_set_reg0x3_value(uint32_t value)
263 {
264 REG_WRITE(JPEG_DEC_REG0X3_ADDR,value);
265 }
266
267 /* REG_0x03:reg0x3->uv_vld:0x3[0],uv valid,0x0,R/W*/
jpeg_dec_ll_get_reg0x3_uv_vld(void)268 static inline uint32_t jpeg_dec_ll_get_reg0x3_uv_vld(void)
269 {
270 uint32_t reg_value;
271 reg_value = REG_READ(JPEG_DEC_REG0X3_ADDR);
272 reg_value = ((reg_value >> JPEG_DEC_REG0X3_UV_VLD_POS) & JPEG_DEC_REG0X3_UV_VLD_MASK);
273 return reg_value;
274 }
275
jpeg_dec_ll_set_reg0x3_uv_vld(uint32_t value)276 static inline void jpeg_dec_ll_set_reg0x3_uv_vld(uint32_t value)
277 {
278 uint32_t reg_value;
279 reg_value = REG_READ(JPEG_DEC_REG0X3_ADDR);
280 reg_value &= ~(JPEG_DEC_REG0X3_UV_VLD_MASK << JPEG_DEC_REG0X3_UV_VLD_POS);
281 reg_value |= ((value & JPEG_DEC_REG0X3_UV_VLD_MASK) << JPEG_DEC_REG0X3_UV_VLD_POS);
282 REG_WRITE(JPEG_DEC_REG0X3_ADDR,reg_value);
283 }
284
285 /* REG_0x04 */
286 #define JPEG_DEC_REG0X4_ADDR (JPEG_DEC_LL_REG_BASE + 0x4*4) //REG ADDR :0x48040010
287 #define JPEG_DEC_REG0X4_JD_MASK_CUR_POS (0)
288 #define JPEG_DEC_REG0X4_JD_MASK_CUR_MASK (0xFFFFFFFF)
289
jpeg_dec_ll_get_reg0x4_value(void)290 static inline uint32_t jpeg_dec_ll_get_reg0x4_value(void)
291 {
292 return REG_READ(JPEG_DEC_REG0X4_ADDR);
293 }
294
295 /* REG_0x04:reg0x4->jd_mask_cur:0x4[31:0],current mask of one byte,0x0,R*/
jpeg_dec_ll_get_reg0x4_jd_mask_cur(void)296 static inline uint32_t jpeg_dec_ll_get_reg0x4_jd_mask_cur(void)
297 {
298 return REG_READ(JPEG_DEC_REG0X4_ADDR);
299 }
300
301 /* REG_0x05 */
302 #define JPEG_DEC_REG0X5_ADDR (JPEG_DEC_LL_REG_BASE + 0x5*4) //REG ADDR :0x48040014
303 #define JPEG_DEC_REG0X5_MCU_X_POS (0)
304 #define JPEG_DEC_REG0X5_MCU_X_MASK (0xFFFF)
305
306 #define JPEG_DEC_REG0X5_RESERVED_POS (16)
307 #define JPEG_DEC_REG0X5_RESERVED_MASK (0xFFFF)
308
jpeg_dec_ll_get_reg0x5_value(void)309 static inline uint32_t jpeg_dec_ll_get_reg0x5_value(void)
310 {
311 return REG_READ(JPEG_DEC_REG0X5_ADDR);
312 }
313
jpeg_dec_ll_set_reg0x5_value(uint32_t value)314 static inline void jpeg_dec_ll_set_reg0x5_value(uint32_t value)
315 {
316 REG_WRITE(JPEG_DEC_REG0X5_ADDR,value);
317 }
318
319 /* REG_0x05:reg0x5->mcu_x:0x5[15:0],mcu_x index,0x0,R/W*/
jpeg_dec_ll_get_reg0x5_mcu_x(void)320 static inline uint32_t jpeg_dec_ll_get_reg0x5_mcu_x(void)
321 {
322 uint32_t reg_value;
323 reg_value = REG_READ(JPEG_DEC_REG0X5_ADDR);
324 reg_value = ((reg_value >> JPEG_DEC_REG0X5_MCU_X_POS) & JPEG_DEC_REG0X5_MCU_X_MASK);
325 return reg_value;
326 }
327
jpeg_dec_ll_set_reg0x5_mcu_x(uint32_t value)328 static inline void jpeg_dec_ll_set_reg0x5_mcu_x(uint32_t value)
329 {
330 uint32_t reg_value;
331 reg_value = REG_READ(JPEG_DEC_REG0X5_ADDR);
332 reg_value &= ~(JPEG_DEC_REG0X5_MCU_X_MASK << JPEG_DEC_REG0X5_MCU_X_POS);
333 reg_value |= ((value & JPEG_DEC_REG0X5_MCU_X_MASK) << JPEG_DEC_REG0X5_MCU_X_POS);
334 REG_WRITE(JPEG_DEC_REG0X5_ADDR,reg_value);
335 }
336
337 /* REG_0x06 */
338 #define JPEG_DEC_REG0X6_ADDR (JPEG_DEC_LL_REG_BASE + 0x6*4) //REG ADDR :0x48040018
339 #define JPEG_DEC_REG0X6_MCU_Y_POS (0)
340 #define JPEG_DEC_REG0X6_MCU_Y_MASK (0xFFFF)
341
342 #define JPEG_DEC_REG0X6_RESERVED_POS (16)
343 #define JPEG_DEC_REG0X6_RESERVED_MASK (0xFFFF)
344
jpeg_dec_ll_get_reg0x6_value(void)345 static inline uint32_t jpeg_dec_ll_get_reg0x6_value(void)
346 {
347 return REG_READ(JPEG_DEC_REG0X6_ADDR);
348 }
349
jpeg_dec_ll_set_reg0x6_value(uint32_t value)350 static inline void jpeg_dec_ll_set_reg0x6_value(uint32_t value)
351 {
352 REG_WRITE(JPEG_DEC_REG0X6_ADDR,value);
353 }
354
355 /* REG_0x06:reg0x6->mcu_y:0x6[15:0],mcu_y index,0x0,R/W*/
jpeg_dec_ll_get_reg0x6_mcu_y(void)356 static inline uint32_t jpeg_dec_ll_get_reg0x6_mcu_y(void)
357 {
358 uint32_t reg_value;
359 reg_value = REG_READ(JPEG_DEC_REG0X6_ADDR);
360 reg_value = ((reg_value >> JPEG_DEC_REG0X6_MCU_Y_POS) & JPEG_DEC_REG0X6_MCU_Y_MASK);
361 return reg_value;
362 }
363
jpeg_dec_ll_set_reg0x6_mcu_y(uint32_t value)364 static inline void jpeg_dec_ll_set_reg0x6_mcu_y(uint32_t value)
365 {
366 uint32_t reg_value;
367 reg_value = REG_READ(JPEG_DEC_REG0X6_ADDR);
368 reg_value &= ~(JPEG_DEC_REG0X6_MCU_Y_MASK << JPEG_DEC_REG0X6_MCU_Y_POS);
369 reg_value |= ((value & JPEG_DEC_REG0X6_MCU_Y_MASK) << JPEG_DEC_REG0X6_MCU_Y_POS);
370 REG_WRITE(JPEG_DEC_REG0X6_ADDR,reg_value);
371 }
372
373 /* REG_0x07 */
374 #define JPEG_DEC_REG0X7_ADDR (JPEG_DEC_LL_REG_BASE + 0x7*4) //REG ADDR :0x4804001c
375 #define JPEG_DEC_REG0X7_V_VLD_NUM_POS (0)
376 #define JPEG_DEC_REG0X7_V_VLD_NUM_MASK (0xF)
377
378 #define JPEG_DEC_REG0X7_RESERVED_POS (4)
379 #define JPEG_DEC_REG0X7_RESERVED_MASK (0xFFFFFFF)
380
jpeg_dec_ll_get_reg0x7_value(void)381 static inline uint32_t jpeg_dec_ll_get_reg0x7_value(void)
382 {
383 return REG_READ(JPEG_DEC_REG0X7_ADDR);
384 }
385
jpeg_dec_ll_set_reg0x7_value(uint32_t value)386 static inline void jpeg_dec_ll_set_reg0x7_value(uint32_t value)
387 {
388 REG_WRITE(JPEG_DEC_REG0X7_ADDR,value);
389 }
390
391 /* REG_0x07:reg0x7->v_vld_num:0x7[3:0],v valid number, default: 1 U:V ,0x0,R/W*/
jpeg_dec_ll_get_reg0x7_v_vld_num(void)392 static inline uint32_t jpeg_dec_ll_get_reg0x7_v_vld_num(void)
393 {
394 uint32_t reg_value;
395 reg_value = REG_READ(JPEG_DEC_REG0X7_ADDR);
396 reg_value = ((reg_value >> JPEG_DEC_REG0X7_V_VLD_NUM_POS) & JPEG_DEC_REG0X7_V_VLD_NUM_MASK);
397 return reg_value;
398 }
399
jpeg_dec_ll_set_reg0x7_v_vld_num(uint32_t value)400 static inline void jpeg_dec_ll_set_reg0x7_v_vld_num(uint32_t value)
401 {
402 uint32_t reg_value;
403 reg_value = REG_READ(JPEG_DEC_REG0X7_ADDR);
404 reg_value &= ~(JPEG_DEC_REG0X7_V_VLD_NUM_MASK << JPEG_DEC_REG0X7_V_VLD_NUM_POS);
405 reg_value |= ((value & JPEG_DEC_REG0X7_V_VLD_NUM_MASK) << JPEG_DEC_REG0X7_V_VLD_NUM_POS);
406 REG_WRITE(JPEG_DEC_REG0X7_ADDR,reg_value);
407 }
408
409 /* REG_0x08 */
410 #define JPEG_DEC_REG0X8_ADDR (JPEG_DEC_LL_REG_BASE + 0x8*4) //REG ADDR :0x48040020
411 #define JPEG_DEC_REG0X8_DEC_CMD_POS (0)
412 #define JPEG_DEC_REG0X8_DEC_CMD_MASK (0xF)
413
414 #define JPEG_DEC_REG0X8_RESERVED_POS (4)
415 #define JPEG_DEC_REG0X8_RESERVED_MASK (0xFFFFFFF)
416
jpeg_dec_ll_set_reg0x8_value(uint32_t value)417 static inline void jpeg_dec_ll_set_reg0x8_value(uint32_t value)
418 {
419 REG_WRITE(JPEG_DEC_REG0X8_ADDR,value);
420 }
421
422 /* REG_0x08:reg0x8->DEC_CMD:0x8[3:0],4'b0001: dec_start; 4'b0100: dc value clr,0x0,W*/
jpeg_dec_ll_set_reg0x8_dec_cmd(uint32_t value)423 static inline void jpeg_dec_ll_set_reg0x8_dec_cmd(uint32_t value)
424 {
425 uint32_t reg_value;
426 reg_value = REG_READ(JPEG_DEC_REG0X8_ADDR);
427 reg_value &= ~(JPEG_DEC_REG0X8_DEC_CMD_MASK << JPEG_DEC_REG0X8_DEC_CMD_POS);
428 reg_value |= ((value & JPEG_DEC_REG0X8_DEC_CMD_MASK) << JPEG_DEC_REG0X8_DEC_CMD_POS);
429 REG_WRITE(JPEG_DEC_REG0X8_ADDR,reg_value);
430 }
431
432 /* REG_0x09 */
433 #define JPEG_DEC_REG0X9_ADDR (JPEG_DEC_LL_REG_BASE + 0x9*4) //REG ADDR :0x48040024
434 #define JPEG_DEC_REG0X9_CUR_RUN_POS (0)
435 #define JPEG_DEC_REG0X9_CUR_RUN_MASK (0xFFFFFFFF)
436
jpeg_dec_ll_get_reg0x9_value(void)437 static inline uint32_t jpeg_dec_ll_get_reg0x9_value(void)
438 {
439 return REG_READ(JPEG_DEC_REG0X9_ADDR);
440 }
441
442 /* REG_0x09:reg0x9->cur_run:0x9[31:0],current run,0x0,R*/
jpeg_dec_ll_get_reg0x9_cur_run(void)443 static inline uint32_t jpeg_dec_ll_get_reg0x9_cur_run(void)
444 {
445 return REG_READ(JPEG_DEC_REG0X9_ADDR);
446 }
447
448 /* REG_0x0A */
449 #define JPEG_DEC_REG0XA_ADDR (JPEG_DEC_LL_REG_BASE + 0xA*4) //REG ADDR :0x48040028
450 #define JPEG_DEC_REG0XA_X_PIXEL_POS (0)
451 #define JPEG_DEC_REG0XA_X_PIXEL_MASK (0xFFFF)
452
453 #define JPEG_DEC_REG0XA_RESERVED_POS (16)
454 #define JPEG_DEC_REG0XA_RESERVED_MASK (0xFFFF)
455
jpeg_dec_ll_get_reg0xa_value(void)456 static inline uint32_t jpeg_dec_ll_get_reg0xa_value(void)
457 {
458 return REG_READ(JPEG_DEC_REG0XA_ADDR);
459 }
460
jpeg_dec_ll_set_reg0xa_value(uint32_t value)461 static inline void jpeg_dec_ll_set_reg0xa_value(uint32_t value)
462 {
463 REG_WRITE(JPEG_DEC_REG0XA_ADDR,value);
464 }
465
466 /* REG_0x0a:reg0xa->x_pixel:0xa[15:0],pixel number X,0x0,R/W*/
jpeg_dec_ll_get_reg0xa_x_pixel(void)467 static inline uint32_t jpeg_dec_ll_get_reg0xa_x_pixel(void)
468 {
469 uint32_t reg_value;
470 reg_value = REG_READ(JPEG_DEC_REG0XA_ADDR);
471 reg_value = ((reg_value >> JPEG_DEC_REG0XA_X_PIXEL_POS) & JPEG_DEC_REG0XA_X_PIXEL_MASK);
472 return reg_value;
473 }
474
jpeg_dec_ll_set_reg0xa_x_pixel(uint32_t value)475 static inline void jpeg_dec_ll_set_reg0xa_x_pixel(uint32_t value)
476 {
477 uint32_t reg_value;
478 reg_value = REG_READ(JPEG_DEC_REG0XA_ADDR);
479 reg_value &= ~(JPEG_DEC_REG0XA_X_PIXEL_MASK << JPEG_DEC_REG0XA_X_PIXEL_POS);
480 reg_value |= ((value & JPEG_DEC_REG0XA_X_PIXEL_MASK) << JPEG_DEC_REG0XA_X_PIXEL_POS);
481 REG_WRITE(JPEG_DEC_REG0XA_ADDR,reg_value);
482 }
483
484 /* REG_0x0B */
485 #define JPEG_DEC_REG0XB_ADDR (JPEG_DEC_LL_REG_BASE + 0xB*4) //REG ADDR :0x4804002c
486 #define JPEG_DEC_REG0XB_HUF_DATA_POS (0)
487 #define JPEG_DEC_REG0XB_HUF_DATA_MASK (0xFFFFFFFF)
488
jpeg_dec_ll_get_reg0xb_value(void)489 static inline uint32_t jpeg_dec_ll_get_reg0xb_value(void)
490 {
491 return REG_READ(JPEG_DEC_REG0XB_ADDR);
492 }
493
494 /* REG_0x0b:reg0xb->huf_data:0xb[31:0],huffman data,0x0,R*/
jpeg_dec_ll_get_reg0xb_huf_data(void)495 static inline uint32_t jpeg_dec_ll_get_reg0xb_huf_data(void)
496 {
497 return REG_READ(JPEG_DEC_REG0XB_ADDR);
498 }
499
500 /* REG_0x0C */
501 #define JPEG_DEC_REG0XC_ADDR (JPEG_DEC_LL_REG_BASE + 0xC*4) //REG ADDR :0x48040030
502 #define JPEG_DEC_REG0XC_CUR_NBIT_POS (0)
503 #define JPEG_DEC_REG0XC_CUR_NBIT_MASK (0xFFFFFFFF)
504
jpeg_dec_ll_get_reg0xc_value(void)505 static inline uint32_t jpeg_dec_ll_get_reg0xc_value(void)
506 {
507 return REG_READ(JPEG_DEC_REG0XC_ADDR);
508 }
509
510 /* REG_0x0c:reg0xc->cur_nbit:0xc[31:0],current nbit,0x0,R*/
jpeg_dec_ll_get_reg0xc_cur_nbit(void)511 static inline uint32_t jpeg_dec_ll_get_reg0xc_cur_nbit(void)
512 {
513 return REG_READ(JPEG_DEC_REG0XC_ADDR);
514 }
515
516 /* REG_0x0D */
517 #define JPEG_DEC_REG0XD_ADDR (JPEG_DEC_LL_REG_BASE + 0xD*4) //REG ADDR :0x48040034
518 #define JPEG_DEC_REG0XD_STATE_DEC_BUSY_POS (0)
519 #define JPEG_DEC_REG0XD_STATE_DEC_BUSY_MASK (0x1)
520
521 #define JPEG_DEC_REG0XD_STATE_RRLOAD_POS (1)
522 #define JPEG_DEC_REG0XD_STATE_RRLOAD_MASK (0x1)
523
524 #define JPEG_DEC_REG0XD_STATE_RLOAD_POS (2)
525 #define JPEG_DEC_REG0XD_STATE_RLOAD_MASK (0x1)
526
527 #define JPEG_DEC_REG0XD_STATE_SEARCH_POS (3)
528 #define JPEG_DEC_REG0XD_STATE_SEARCH_MASK (0x1)
529
530 #define JPEG_DEC_REG0XD_STATE_EXT_RLOAD_POS (4)
531 #define JPEG_DEC_REG0XD_STATE_EXT_RLOAD_MASK (0x1)
532
533 #define JPEG_DEC_REG0XD_STATE_EXT_BITS_POS (5)
534 #define JPEG_DEC_REG0XD_STATE_EXT_BITS_MASK (0x1)
535
536 #define JPEG_DEC_REG0XD_STATE_IDCT_POS (6)
537 #define JPEG_DEC_REG0XD_STATE_IDCT_MASK (0x1)
538
539 #define JPEG_DEC_REG0XD_TMP_WR0_POS (7)
540 #define JPEG_DEC_REG0XD_TMP_WR0_MASK (0x1)
541
542 #define JPEG_DEC_REG0XD_STATE_DEC_BUSY2_POS (8)
543 #define JPEG_DEC_REG0XD_STATE_DEC_BUSY2_MASK (0x1)
544
545 #define JPEG_DEC_REG0XD_STATE_AHBMST_IDLE_POS (9)
546 #define JPEG_DEC_REG0XD_STATE_AHBMST_IDLE_MASK (0x1)
547
548 #define JPEG_DEC_REG0XD_RESERVED_POS (10)
549 #define JPEG_DEC_REG0XD_RESERVED_MASK (0x3FFFFF)
550
jpeg_dec_ll_get_reg0xd_value(void)551 static inline uint32_t jpeg_dec_ll_get_reg0xd_value(void)
552 {
553 return REG_READ(JPEG_DEC_REG0XD_ADDR);
554 }
555
556 /* REG_0x0d:reg0xd->state_dec_busy:0xd[0],state_dec_busy,None,R*/
jpeg_dec_ll_get_reg0xd_state_dec_busy(void)557 static inline uint32_t jpeg_dec_ll_get_reg0xd_state_dec_busy(void)
558 {
559 uint32_t reg_value;
560 reg_value = REG_READ(JPEG_DEC_REG0XD_ADDR);
561 reg_value = ((reg_value >> JPEG_DEC_REG0XD_STATE_DEC_BUSY_POS)&JPEG_DEC_REG0XD_STATE_DEC_BUSY_MASK);
562 return reg_value;
563 }
564
565 /* REG_0x0d:reg0xd->state_rrload:0xd[1],state_rrload,None,R*/
jpeg_dec_ll_get_reg0xd_state_rrload(void)566 static inline uint32_t jpeg_dec_ll_get_reg0xd_state_rrload(void)
567 {
568 uint32_t reg_value;
569 reg_value = REG_READ(JPEG_DEC_REG0XD_ADDR);
570 reg_value = ((reg_value >> JPEG_DEC_REG0XD_STATE_RRLOAD_POS)&JPEG_DEC_REG0XD_STATE_RRLOAD_MASK);
571 return reg_value;
572 }
573
574 /* REG_0x0d:reg0xd->state_rload:0xd[2],state_rload,None,R*/
jpeg_dec_ll_get_reg0xd_state_rload(void)575 static inline uint32_t jpeg_dec_ll_get_reg0xd_state_rload(void)
576 {
577 uint32_t reg_value;
578 reg_value = REG_READ(JPEG_DEC_REG0XD_ADDR);
579 reg_value = ((reg_value >> JPEG_DEC_REG0XD_STATE_RLOAD_POS)&JPEG_DEC_REG0XD_STATE_RLOAD_MASK);
580 return reg_value;
581 }
582
583 /* REG_0x0d:reg0xd->state_search:0xd[3],state_search,None,R*/
jpeg_dec_ll_get_reg0xd_state_search(void)584 static inline uint32_t jpeg_dec_ll_get_reg0xd_state_search(void)
585 {
586 uint32_t reg_value;
587 reg_value = REG_READ(JPEG_DEC_REG0XD_ADDR);
588 reg_value = ((reg_value >> JPEG_DEC_REG0XD_STATE_SEARCH_POS)&JPEG_DEC_REG0XD_STATE_SEARCH_MASK);
589 return reg_value;
590 }
591
592 /* REG_0x0d:reg0xd->state_ext_rload:0xd[4],state_ext_rload,None,R*/
jpeg_dec_ll_get_reg0xd_state_ext_rload(void)593 static inline uint32_t jpeg_dec_ll_get_reg0xd_state_ext_rload(void)
594 {
595 uint32_t reg_value;
596 reg_value = REG_READ(JPEG_DEC_REG0XD_ADDR);
597 reg_value = ((reg_value >> JPEG_DEC_REG0XD_STATE_EXT_RLOAD_POS)&JPEG_DEC_REG0XD_STATE_EXT_RLOAD_MASK);
598 return reg_value;
599 }
600
601 /* REG_0x0d:reg0xd->state_ext_bits:0xd[5],state_ext_bits,None,R*/
jpeg_dec_ll_get_reg0xd_state_ext_bits(void)602 static inline uint32_t jpeg_dec_ll_get_reg0xd_state_ext_bits(void)
603 {
604 uint32_t reg_value;
605 reg_value = REG_READ(JPEG_DEC_REG0XD_ADDR);
606 reg_value = ((reg_value >> JPEG_DEC_REG0XD_STATE_EXT_BITS_POS)&JPEG_DEC_REG0XD_STATE_EXT_BITS_MASK);
607 return reg_value;
608 }
609
610 /* REG_0x0d:reg0xd->state_idct:0xd[6],state_idct,None,R*/
jpeg_dec_ll_get_reg0xd_state_idct(void)611 static inline uint32_t jpeg_dec_ll_get_reg0xd_state_idct(void)
612 {
613 uint32_t reg_value;
614 reg_value = REG_READ(JPEG_DEC_REG0XD_ADDR);
615 reg_value = ((reg_value >> JPEG_DEC_REG0XD_STATE_IDCT_POS)&JPEG_DEC_REG0XD_STATE_IDCT_MASK);
616 return reg_value;
617 }
618
619 /* REG_0x0d:reg0xd->tmp_wr0:0xd[7],tmp_wr0,None,R*/
jpeg_dec_ll_get_reg0xd_tmp_wr0(void)620 static inline uint32_t jpeg_dec_ll_get_reg0xd_tmp_wr0(void)
621 {
622 uint32_t reg_value;
623 reg_value = REG_READ(JPEG_DEC_REG0XD_ADDR);
624 reg_value = ((reg_value >> JPEG_DEC_REG0XD_TMP_WR0_POS)&JPEG_DEC_REG0XD_TMP_WR0_MASK);
625 return reg_value;
626 }
627
628 /* REG_0x0d:reg0xd->state_dec_busy2:0xd[8],state_dec_busy2,None,R*/
jpeg_dec_ll_get_reg0xd_state_dec_busy2(void)629 static inline uint32_t jpeg_dec_ll_get_reg0xd_state_dec_busy2(void)
630 {
631 uint32_t reg_value;
632 reg_value = REG_READ(JPEG_DEC_REG0XD_ADDR);
633 reg_value = ((reg_value >> JPEG_DEC_REG0XD_STATE_DEC_BUSY2_POS)&JPEG_DEC_REG0XD_STATE_DEC_BUSY2_MASK);
634 return reg_value;
635 }
636
637 /* REG_0x0d:reg0xd->state_ahbmst_idle:0xd[9],state_ahbmst_idle,None,R*/
jpeg_dec_ll_get_reg0xd_state_ahbmst_idle(void)638 static inline uint32_t jpeg_dec_ll_get_reg0xd_state_ahbmst_idle(void)
639 {
640 uint32_t reg_value;
641 reg_value = REG_READ(JPEG_DEC_REG0XD_ADDR);
642 reg_value = ((reg_value >> JPEG_DEC_REG0XD_STATE_AHBMST_IDLE_POS)&JPEG_DEC_REG0XD_STATE_AHBMST_IDLE_MASK);
643 return reg_value;
644 }
645
646 /* REG_0x0E */
647 #define JPEG_DEC_REG0XE_ADDR (JPEG_DEC_LL_REG_BASE + 0xE*4) //REG ADDR :0x48040038
648 #define JPEG_DEC_REG0XE_EXT_DATA_POS (0)
649 #define JPEG_DEC_REG0XE_EXT_DATA_MASK (0xFFFFFFFF)
650
jpeg_dec_ll_get_reg0xe_value(void)651 static inline uint32_t jpeg_dec_ll_get_reg0xe_value(void)
652 {
653 return REG_READ(JPEG_DEC_REG0XE_ADDR);
654 }
655
656 /* REG_0x0e:reg0xe->ext_data:0xe[31:0],ext data,0x0,R*/
jpeg_dec_ll_get_reg0xe_ext_data(void)657 static inline uint32_t jpeg_dec_ll_get_reg0xe_ext_data(void)
658 {
659 return REG_READ(JPEG_DEC_REG0XE_ADDR);
660 }
661
662 /* REG_0x0F */
663 #define JPEG_DEC_REG0XF_ADDR (JPEG_DEC_LL_REG_BASE + 0xF*4) //REG ADDR :0x4804003c
664 #define JPEG_DEC_REG0XF_MCU_BLK_POS (0)
665 #define JPEG_DEC_REG0XF_MCU_BLK_MASK (0xFF)
666
667 #define JPEG_DEC_REG0XF_RESERVED_POS (8)
668 #define JPEG_DEC_REG0XF_RESERVED_MASK (0xFFFFFF)
669
jpeg_dec_ll_get_reg0xf_value(void)670 static inline uint32_t jpeg_dec_ll_get_reg0xf_value(void)
671 {
672 return REG_READ(JPEG_DEC_REG0XF_ADDR);
673 }
674
jpeg_dec_ll_set_reg0xf_value(uint32_t value)675 static inline void jpeg_dec_ll_set_reg0xf_value(uint32_t value)
676 {
677 REG_WRITE(JPEG_DEC_REG0XF_ADDR,value);
678 }
679
680 /* REG_0x0f:reg0xf->mcu_blk:0xf[7:0],block number of one mcu,0x0,R/W*/
jpeg_dec_ll_get_reg0xf_mcu_blk(void)681 static inline uint32_t jpeg_dec_ll_get_reg0xf_mcu_blk(void)
682 {
683 uint32_t reg_value;
684 reg_value = REG_READ(JPEG_DEC_REG0XF_ADDR);
685 reg_value = ((reg_value >> JPEG_DEC_REG0XF_MCU_BLK_POS) & JPEG_DEC_REG0XF_MCU_BLK_MASK);
686 return reg_value;
687 }
688
jpeg_dec_ll_set_reg0xf_mcu_blk(uint32_t value)689 static inline void jpeg_dec_ll_set_reg0xf_mcu_blk(uint32_t value)
690 {
691 uint32_t reg_value;
692 reg_value = REG_READ(JPEG_DEC_REG0XF_ADDR);
693 reg_value &= ~(JPEG_DEC_REG0XF_MCU_BLK_MASK << JPEG_DEC_REG0XF_MCU_BLK_POS);
694 reg_value |= ((value & JPEG_DEC_REG0XF_MCU_BLK_MASK) << JPEG_DEC_REG0XF_MCU_BLK_POS);
695 REG_WRITE(JPEG_DEC_REG0XF_ADDR,reg_value);
696 }
697
698 /* REG_0x10 */
699 #define JPEG_DEC_REG0X10_ADDR (JPEG_DEC_LL_REG_BASE + 0x10*4) //REG ADDR :0x48040040
700 #define JPEG_DEC_REG0X10_HUFDC_LEN_Y0_POS (0)
701 #define JPEG_DEC_REG0X10_HUFDC_LEN_Y0_MASK (0xFFFFFFFF)
702
jpeg_dec_ll_get_reg0x10_value(void)703 static inline uint32_t jpeg_dec_ll_get_reg0x10_value(void)
704 {
705 return REG_READ(JPEG_DEC_REG0X10_ADDR);
706 }
707
jpeg_dec_ll_set_reg0x10_value(uint32_t value)708 static inline void jpeg_dec_ll_set_reg0x10_value(uint32_t value)
709 {
710 REG_WRITE(JPEG_DEC_REG0X10_ADDR,value);
711 }
712
713 /* REG_0x10:reg0x10->hufdc_len_y0:0x10[31:0],y huffman table dc0,0x0,R/W*/
jpeg_dec_ll_get_reg0x10_hufdc_len_y0(void)714 static inline uint32_t jpeg_dec_ll_get_reg0x10_hufdc_len_y0(void)
715 {
716 return REG_READ(JPEG_DEC_REG0X10_ADDR);
717 }
718
jpeg_dec_ll_set_reg0x10_hufdc_len_y0(uint32_t value)719 static inline void jpeg_dec_ll_set_reg0x10_hufdc_len_y0(uint32_t value)
720 {
721 REG_WRITE(JPEG_DEC_REG0X10_ADDR,value);
722 }
723
724 /* REG_0x11 */
725 #define JPEG_DEC_REG0X11_ADDR (JPEG_DEC_LL_REG_BASE + 0x11*4) //REG ADDR :0x48040044
726 #define JPEG_DEC_REG0X11_HUFDC_LEN_Y1_POS (0)
727 #define JPEG_DEC_REG0X11_HUFDC_LEN_Y1_MASK (0xFFFFFFFF)
728
jpeg_dec_ll_get_reg0x11_value(void)729 static inline uint32_t jpeg_dec_ll_get_reg0x11_value(void)
730 {
731 return REG_READ(JPEG_DEC_REG0X11_ADDR);
732 }
733
jpeg_dec_ll_set_reg0x11_value(uint32_t value)734 static inline void jpeg_dec_ll_set_reg0x11_value(uint32_t value)
735 {
736 REG_WRITE(JPEG_DEC_REG0X11_ADDR,value);
737 }
738
739 /* REG_0x11:reg0x11->hufdc_len_y1:0x11,y huffman table dc1,0x0,R/W*/
jpeg_dec_ll_get_reg0x11_hufdc_len_y1(void)740 static inline uint32_t jpeg_dec_ll_get_reg0x11_hufdc_len_y1(void)
741 {
742 return REG_READ(JPEG_DEC_REG0X11_ADDR);
743 }
744
jpeg_dec_ll_set_reg0x11_hufdc_len_y1(uint32_t value)745 static inline void jpeg_dec_ll_set_reg0x11_hufdc_len_y1(uint32_t value)
746 {
747 REG_WRITE(JPEG_DEC_REG0X11_ADDR,value);
748 }
749
750 /* REG_0x12 */
751 #define JPEG_DEC_REG0X12_ADDR (JPEG_DEC_LL_REG_BASE + 0x12*4) //REG ADDR :0x48040048
752 #define JPEG_DEC_REG0X12_HUFDC_LEN_Y2_POS (0)
753 #define JPEG_DEC_REG0X12_HUFDC_LEN_Y2_MASK (0xFFFFFFFF)
754
jpeg_dec_ll_get_reg0x12_value(void)755 static inline uint32_t jpeg_dec_ll_get_reg0x12_value(void)
756 {
757 return REG_READ(JPEG_DEC_REG0X12_ADDR);
758 }
759
jpeg_dec_ll_set_reg0x12_value(uint32_t value)760 static inline void jpeg_dec_ll_set_reg0x12_value(uint32_t value)
761 {
762 REG_WRITE(JPEG_DEC_REG0X12_ADDR,value);
763 }
764
765 /* REG_0x12:reg0x12->hufdc_len_y2:0x12,y huffman table dc2,0x0,R/W*/
jpeg_dec_ll_get_reg0x12_hufdc_len_y2(void)766 static inline uint32_t jpeg_dec_ll_get_reg0x12_hufdc_len_y2(void)
767 {
768 return REG_READ(JPEG_DEC_REG0X12_ADDR);
769 }
770
jpeg_dec_ll_set_reg0x12_hufdc_len_y2(uint32_t value)771 static inline void jpeg_dec_ll_set_reg0x12_hufdc_len_y2(uint32_t value)
772 {
773 REG_WRITE(JPEG_DEC_REG0X12_ADDR,value);
774 }
775
776 /* REG_0x13 */
777 #define JPEG_DEC_REG0X13_ADDR (JPEG_DEC_LL_REG_BASE + 0x13*4) //REG ADDR :0x4804004c
778 #define JPEG_DEC_REG0X13_HUFDC_LEN_Y3_POS (0)
779 #define JPEG_DEC_REG0X13_HUFDC_LEN_Y3_MASK (0xFFFFFFFF)
780
jpeg_dec_ll_get_reg0x13_value(void)781 static inline uint32_t jpeg_dec_ll_get_reg0x13_value(void)
782 {
783 return REG_READ(JPEG_DEC_REG0X13_ADDR);
784 }
785
jpeg_dec_ll_set_reg0x13_value(uint32_t value)786 static inline void jpeg_dec_ll_set_reg0x13_value(uint32_t value)
787 {
788 REG_WRITE(JPEG_DEC_REG0X13_ADDR,value);
789 }
790
791 /* REG_0x13:reg0x13->hufdc_len_y3:0x13,y huffman table dc3,0x0,R/W*/
jpeg_dec_ll_get_reg0x13_hufdc_len_y3(void)792 static inline uint32_t jpeg_dec_ll_get_reg0x13_hufdc_len_y3(void)
793 {
794 return REG_READ(JPEG_DEC_REG0X13_ADDR);
795 }
796
jpeg_dec_ll_set_reg0x13_hufdc_len_y3(uint32_t value)797 static inline void jpeg_dec_ll_set_reg0x13_hufdc_len_y3(uint32_t value)
798 {
799 REG_WRITE(JPEG_DEC_REG0X13_ADDR,value);
800 }
801
802 /* REG_0x14 */
803 #define JPEG_DEC_REG0X14_ADDR (JPEG_DEC_LL_REG_BASE + 0x14*4) //REG ADDR :0x48040050
804 #define JPEG_DEC_REG0X14_HUFDC_LEN_Y4_POS (0)
805 #define JPEG_DEC_REG0X14_HUFDC_LEN_Y4_MASK (0xFFFFFFFF)
806
jpeg_dec_ll_get_reg0x14_value(void)807 static inline uint32_t jpeg_dec_ll_get_reg0x14_value(void)
808 {
809 return REG_READ(JPEG_DEC_REG0X14_ADDR);
810 }
811
jpeg_dec_ll_set_reg0x14_value(uint32_t value)812 static inline void jpeg_dec_ll_set_reg0x14_value(uint32_t value)
813 {
814 REG_WRITE(JPEG_DEC_REG0X14_ADDR,value);
815 }
816
817 /* REG_0x14:reg0x14->hufdc_len_y4:0x14,y huffman table dc4,0x0,R/W*/
jpeg_dec_ll_get_reg0x14_hufdc_len_y4(void)818 static inline uint32_t jpeg_dec_ll_get_reg0x14_hufdc_len_y4(void)
819 {
820 return REG_READ(JPEG_DEC_REG0X14_ADDR);
821 }
822
jpeg_dec_ll_set_reg0x14_hufdc_len_y4(uint32_t value)823 static inline void jpeg_dec_ll_set_reg0x14_hufdc_len_y4(uint32_t value)
824 {
825 REG_WRITE(JPEG_DEC_REG0X14_ADDR,value);
826 }
827
828 /* REG_0x15 */
829 #define JPEG_DEC_REG0X15_ADDR (JPEG_DEC_LL_REG_BASE + 0x15*4) //REG ADDR :0x48040054
830 #define JPEG_DEC_REG0X15_HUFDC_LEN_Y5_POS (0)
831 #define JPEG_DEC_REG0X15_HUFDC_LEN_Y5_MASK (0xFFFFFFFF)
832
jpeg_dec_ll_get_reg0x15_value(void)833 static inline uint32_t jpeg_dec_ll_get_reg0x15_value(void)
834 {
835 return REG_READ(JPEG_DEC_REG0X15_ADDR);
836 }
837
jpeg_dec_ll_set_reg0x15_value(uint32_t value)838 static inline void jpeg_dec_ll_set_reg0x15_value(uint32_t value)
839 {
840 REG_WRITE(JPEG_DEC_REG0X15_ADDR,value);
841 }
842
843 /* REG_0x15:reg0x15->hufdc_len_y5:0x15,y huffman table dc5,0x0,R/W*/
jpeg_dec_ll_get_reg0x15_hufdc_len_y5(void)844 static inline uint32_t jpeg_dec_ll_get_reg0x15_hufdc_len_y5(void)
845 {
846 return REG_READ(JPEG_DEC_REG0X15_ADDR);
847 }
848
jpeg_dec_ll_set_reg0x15_hufdc_len_y5(uint32_t value)849 static inline void jpeg_dec_ll_set_reg0x15_hufdc_len_y5(uint32_t value)
850 {
851 REG_WRITE(JPEG_DEC_REG0X15_ADDR,value);
852 }
853
854 /* REG_0x16 */
855 #define JPEG_DEC_REG0X16_ADDR (JPEG_DEC_LL_REG_BASE + 0x16*4) //REG ADDR :0x48040058
856 #define JPEG_DEC_REG0X16_HUFDC_LEN_Y6_POS (0)
857 #define JPEG_DEC_REG0X16_HUFDC_LEN_Y6_MASK (0xFFFFFFFF)
858
jpeg_dec_ll_get_reg0x16_value(void)859 static inline uint32_t jpeg_dec_ll_get_reg0x16_value(void)
860 {
861 return REG_READ(JPEG_DEC_REG0X16_ADDR);
862 }
863
jpeg_dec_ll_set_reg0x16_value(uint32_t value)864 static inline void jpeg_dec_ll_set_reg0x16_value(uint32_t value)
865 {
866 REG_WRITE(JPEG_DEC_REG0X16_ADDR,value);
867 }
868
869 /* REG_0x16:reg0x16->hufdc_len_y6:0x16,y huffman table dc6,0x0,R/W*/
jpeg_dec_ll_get_reg0x16_hufdc_len_y6(void)870 static inline uint32_t jpeg_dec_ll_get_reg0x16_hufdc_len_y6(void)
871 {
872 return REG_READ(JPEG_DEC_REG0X16_ADDR);
873 }
874
jpeg_dec_ll_set_reg0x16_hufdc_len_y6(uint32_t value)875 static inline void jpeg_dec_ll_set_reg0x16_hufdc_len_y6(uint32_t value)
876 {
877 REG_WRITE(JPEG_DEC_REG0X16_ADDR,value);
878 }
879
880 /* REG_0x17 */
881 #define JPEG_DEC_REG0X17_ADDR (JPEG_DEC_LL_REG_BASE + 0x17*4) //REG ADDR :0x4804005c
882 #define JPEG_DEC_REG0X17_HUFDC_LEN_Y7_POS (0)
883 #define JPEG_DEC_REG0X17_HUFDC_LEN_Y7_MASK (0xFFFFFFFF)
884
jpeg_dec_ll_get_reg0x17_value(void)885 static inline uint32_t jpeg_dec_ll_get_reg0x17_value(void)
886 {
887 return REG_READ(JPEG_DEC_REG0X17_ADDR);
888 }
889
jpeg_dec_ll_set_reg0x17_value(uint32_t value)890 static inline void jpeg_dec_ll_set_reg0x17_value(uint32_t value)
891 {
892 REG_WRITE(JPEG_DEC_REG0X17_ADDR,value);
893 }
894
895 /* REG_0x17:reg0x17->hufdc_len_y7:0x17,y huffman table dc7,0x0,R/W*/
jpeg_dec_ll_get_reg0x17_hufdc_len_y7(void)896 static inline uint32_t jpeg_dec_ll_get_reg0x17_hufdc_len_y7(void)
897 {
898 return REG_READ(JPEG_DEC_REG0X17_ADDR);
899 }
900
jpeg_dec_ll_set_reg0x17_hufdc_len_y7(uint32_t value)901 static inline void jpeg_dec_ll_set_reg0x17_hufdc_len_y7(uint32_t value)
902 {
903 REG_WRITE(JPEG_DEC_REG0X17_ADDR,value);
904 }
905
906 /* REG_0x18 */
907 #define JPEG_DEC_REG0X18_ADDR (JPEG_DEC_LL_REG_BASE + 0x18*4) //REG ADDR :0x48040060
908 #define JPEG_DEC_REG0X18_HUFDC_LEN_Y8_POS (0)
909 #define JPEG_DEC_REG0X18_HUFDC_LEN_Y8_MASK (0xFFFFFFFF)
910
jpeg_dec_ll_get_reg0x18_value(void)911 static inline uint32_t jpeg_dec_ll_get_reg0x18_value(void)
912 {
913 return REG_READ(JPEG_DEC_REG0X18_ADDR);
914 }
915
jpeg_dec_ll_set_reg0x18_value(uint32_t value)916 static inline void jpeg_dec_ll_set_reg0x18_value(uint32_t value)
917 {
918 REG_WRITE(JPEG_DEC_REG0X18_ADDR,value);
919 }
920
921 /* REG_0x18:reg0x18->hufdc_len_y8:0x18,y huffman table dc8,0x0,R/W*/
jpeg_dec_ll_get_reg0x18_hufdc_len_y8(void)922 static inline uint32_t jpeg_dec_ll_get_reg0x18_hufdc_len_y8(void)
923 {
924 return REG_READ(JPEG_DEC_REG0X18_ADDR);
925 }
926
jpeg_dec_ll_set_reg0x18_hufdc_len_y8(uint32_t value)927 static inline void jpeg_dec_ll_set_reg0x18_hufdc_len_y8(uint32_t value)
928 {
929 REG_WRITE(JPEG_DEC_REG0X18_ADDR,value);
930 }
931
932 /* REG_0x19 */
933 #define JPEG_DEC_REG0X19_ADDR (JPEG_DEC_LL_REG_BASE + 0x19*4) //REG ADDR :0x48040064
934 #define JPEG_DEC_REG0X19_HUFDC_LEN_Y9_POS (0)
935 #define JPEG_DEC_REG0X19_HUFDC_LEN_Y9_MASK (0xFFFFFFFF)
936
jpeg_dec_ll_get_reg0x19_value(void)937 static inline uint32_t jpeg_dec_ll_get_reg0x19_value(void)
938 {
939 return REG_READ(JPEG_DEC_REG0X19_ADDR);
940 }
941
jpeg_dec_ll_set_reg0x19_value(uint32_t value)942 static inline void jpeg_dec_ll_set_reg0x19_value(uint32_t value)
943 {
944 REG_WRITE(JPEG_DEC_REG0X19_ADDR,value);
945 }
946
947 /* REG_0x19:reg0x19->hufdc_len_y9:0x19,y huffman table dc9,0x0,R/W*/
jpeg_dec_ll_get_reg0x19_hufdc_len_y9(void)948 static inline uint32_t jpeg_dec_ll_get_reg0x19_hufdc_len_y9(void)
949 {
950 return REG_READ(JPEG_DEC_REG0X19_ADDR);
951 }
952
jpeg_dec_ll_set_reg0x19_hufdc_len_y9(uint32_t value)953 static inline void jpeg_dec_ll_set_reg0x19_hufdc_len_y9(uint32_t value)
954 {
955 REG_WRITE(JPEG_DEC_REG0X19_ADDR,value);
956 }
957
958 /* REG_0x1A */
959 #define JPEG_DEC_REG0X1A_ADDR (JPEG_DEC_LL_REG_BASE + 0x1A*4) //REG ADDR :0x48040068
960 #define JPEG_DEC_REG0X1A_HUFDC_LEN_YA_POS (0)
961 #define JPEG_DEC_REG0X1A_HUFDC_LEN_YA_MASK (0xFFFFFFFF)
962
jpeg_dec_ll_get_reg0x1a_value(void)963 static inline uint32_t jpeg_dec_ll_get_reg0x1a_value(void)
964 {
965 return REG_READ(JPEG_DEC_REG0X1A_ADDR);
966 }
967
jpeg_dec_ll_set_reg0x1a_value(uint32_t value)968 static inline void jpeg_dec_ll_set_reg0x1a_value(uint32_t value)
969 {
970 REG_WRITE(JPEG_DEC_REG0X1A_ADDR,value);
971 }
972
973 /* REG_0x1a:reg0x1a->hufdc_len_ya:0x1a,y huffman table dca,0x0,R/W*/
jpeg_dec_ll_get_reg0x1a_hufdc_len_ya(void)974 static inline uint32_t jpeg_dec_ll_get_reg0x1a_hufdc_len_ya(void)
975 {
976 return REG_READ(JPEG_DEC_REG0X1A_ADDR);
977 }
978
jpeg_dec_ll_set_reg0x1a_hufdc_len_ya(uint32_t value)979 static inline void jpeg_dec_ll_set_reg0x1a_hufdc_len_ya(uint32_t value)
980 {
981 REG_WRITE(JPEG_DEC_REG0X1A_ADDR,value);
982 }
983
984 /* REG_0x1B */
985 #define JPEG_DEC_REG0X1B_ADDR (JPEG_DEC_LL_REG_BASE + 0x1B*4) //REG ADDR :0x4804006c
986 #define JPEG_DEC_REG0X1B_HUFDC_LEN_YB_POS (0)
987 #define JPEG_DEC_REG0X1B_HUFDC_LEN_YB_MASK (0xFFFFFFFF)
988
jpeg_dec_ll_get_reg0x1b_value(void)989 static inline uint32_t jpeg_dec_ll_get_reg0x1b_value(void)
990 {
991 return REG_READ(JPEG_DEC_REG0X1B_ADDR);
992 }
993
jpeg_dec_ll_set_reg0x1b_value(uint32_t value)994 static inline void jpeg_dec_ll_set_reg0x1b_value(uint32_t value)
995 {
996 REG_WRITE(JPEG_DEC_REG0X1B_ADDR,value);
997 }
998
999 /* REG_0x1b:reg0x1b->hufdc_len_yb:0x1b,y huffman table dcb,0x0,R/W*/
jpeg_dec_ll_get_reg0x1b_hufdc_len_yb(void)1000 static inline uint32_t jpeg_dec_ll_get_reg0x1b_hufdc_len_yb(void)
1001 {
1002 return REG_READ(JPEG_DEC_REG0X1B_ADDR);
1003 }
1004
jpeg_dec_ll_set_reg0x1b_hufdc_len_yb(uint32_t value)1005 static inline void jpeg_dec_ll_set_reg0x1b_hufdc_len_yb(uint32_t value)
1006 {
1007 REG_WRITE(JPEG_DEC_REG0X1B_ADDR,value);
1008 }
1009
1010 /* REG_0x1C */
1011 #define JPEG_DEC_REG0X1C_ADDR (JPEG_DEC_LL_REG_BASE + 0x1C*4) //REG ADDR :0x48040070
1012 #define JPEG_DEC_REG0X1C_HUFDC_LEN_YC_POS (0)
1013 #define JPEG_DEC_REG0X1C_HUFDC_LEN_YC_MASK (0xFFFFFFFF)
1014
jpeg_dec_ll_get_reg0x1c_value(void)1015 static inline uint32_t jpeg_dec_ll_get_reg0x1c_value(void)
1016 {
1017 return REG_READ(JPEG_DEC_REG0X1C_ADDR);
1018 }
1019
jpeg_dec_ll_set_reg0x1c_value(uint32_t value)1020 static inline void jpeg_dec_ll_set_reg0x1c_value(uint32_t value)
1021 {
1022 REG_WRITE(JPEG_DEC_REG0X1C_ADDR,value);
1023 }
1024
1025 /* REG_0x1c:reg0x1c->hufdc_len_yc:0x1c,y huffman table dcc,0x0,R/W*/
jpeg_dec_ll_get_reg0x1c_hufdc_len_yc(void)1026 static inline uint32_t jpeg_dec_ll_get_reg0x1c_hufdc_len_yc(void)
1027 {
1028 return REG_READ(JPEG_DEC_REG0X1C_ADDR);
1029 }
1030
jpeg_dec_ll_set_reg0x1c_hufdc_len_yc(uint32_t value)1031 static inline void jpeg_dec_ll_set_reg0x1c_hufdc_len_yc(uint32_t value)
1032 {
1033 REG_WRITE(JPEG_DEC_REG0X1C_ADDR,value);
1034 }
1035
1036 /* REG_0x1D */
1037 #define JPEG_DEC_REG0X1D_ADDR (JPEG_DEC_LL_REG_BASE + 0x1D*4) //REG ADDR :0x48040074
1038 #define JPEG_DEC_REG0X1D_HUFDC_LEN_YD_POS (0)
1039 #define JPEG_DEC_REG0X1D_HUFDC_LEN_YD_MASK (0xFFFFFFFF)
1040
jpeg_dec_ll_get_reg0x1d_value(void)1041 static inline uint32_t jpeg_dec_ll_get_reg0x1d_value(void)
1042 {
1043 return REG_READ(JPEG_DEC_REG0X1D_ADDR);
1044 }
1045
jpeg_dec_ll_set_reg0x1d_value(uint32_t value)1046 static inline void jpeg_dec_ll_set_reg0x1d_value(uint32_t value)
1047 {
1048 REG_WRITE(JPEG_DEC_REG0X1D_ADDR,value);
1049 }
1050
1051 /* REG_0x1d:reg0x1d->hufdc_len_yd:0x1d,y huffman table dcd,0x0,R/W*/
jpeg_dec_ll_get_reg0x1d_hufdc_len_yd(void)1052 static inline uint32_t jpeg_dec_ll_get_reg0x1d_hufdc_len_yd(void)
1053 {
1054 return REG_READ(JPEG_DEC_REG0X1D_ADDR);
1055 }
1056
jpeg_dec_ll_set_reg0x1d_hufdc_len_yd(uint32_t value)1057 static inline void jpeg_dec_ll_set_reg0x1d_hufdc_len_yd(uint32_t value)
1058 {
1059 REG_WRITE(JPEG_DEC_REG0X1D_ADDR,value);
1060 }
1061
1062 /* REG_0x1E */
1063 #define JPEG_DEC_REG0X1E_ADDR (JPEG_DEC_LL_REG_BASE + 0x1E*4) //REG ADDR :0x48040078
1064 #define JPEG_DEC_REG0X1E_HUFDC_LEN_YE_POS (0)
1065 #define JPEG_DEC_REG0X1E_HUFDC_LEN_YE_MASK (0xFFFFFFFF)
1066
jpeg_dec_ll_get_reg0x1e_value(void)1067 static inline uint32_t jpeg_dec_ll_get_reg0x1e_value(void)
1068 {
1069 return REG_READ(JPEG_DEC_REG0X1E_ADDR);
1070 }
1071
jpeg_dec_ll_set_reg0x1e_value(uint32_t value)1072 static inline void jpeg_dec_ll_set_reg0x1e_value(uint32_t value)
1073 {
1074 REG_WRITE(JPEG_DEC_REG0X1E_ADDR,value);
1075 }
1076
1077 /* REG_0x1e:reg0x1e->hufdc_len_ye:0x1e,y huffman table dce,0x0,R/W*/
jpeg_dec_ll_get_reg0x1e_hufdc_len_ye(void)1078 static inline uint32_t jpeg_dec_ll_get_reg0x1e_hufdc_len_ye(void)
1079 {
1080 return REG_READ(JPEG_DEC_REG0X1E_ADDR);
1081 }
1082
jpeg_dec_ll_set_reg0x1e_hufdc_len_ye(uint32_t value)1083 static inline void jpeg_dec_ll_set_reg0x1e_hufdc_len_ye(uint32_t value)
1084 {
1085 REG_WRITE(JPEG_DEC_REG0X1E_ADDR,value);
1086 }
1087
1088 /* REG_0x1F */
1089 #define JPEG_DEC_REG0X1F_ADDR (JPEG_DEC_LL_REG_BASE + 0x1F*4) //REG ADDR :0x4804007c
1090 #define JPEG_DEC_REG0X1F_HUFDC_LEN_YF_POS (0)
1091 #define JPEG_DEC_REG0X1F_HUFDC_LEN_YF_MASK (0xFFFFFFFF)
1092
jpeg_dec_ll_get_reg0x1f_value(void)1093 static inline uint32_t jpeg_dec_ll_get_reg0x1f_value(void)
1094 {
1095 return REG_READ(JPEG_DEC_REG0X1F_ADDR);
1096 }
1097
jpeg_dec_ll_set_reg0x1f_value(uint32_t value)1098 static inline void jpeg_dec_ll_set_reg0x1f_value(uint32_t value)
1099 {
1100 REG_WRITE(JPEG_DEC_REG0X1F_ADDR,value);
1101 }
1102
1103 /* REG_0x1f:reg0x1f->hufdc_len_yf:0x1f,y huffman table dcf,0x0,R/W*/
jpeg_dec_ll_get_reg0x1f_hufdc_len_yf(void)1104 static inline uint32_t jpeg_dec_ll_get_reg0x1f_hufdc_len_yf(void)
1105 {
1106 return REG_READ(JPEG_DEC_REG0X1F_ADDR);
1107 }
1108
jpeg_dec_ll_set_reg0x1f_hufdc_len_yf(uint32_t value)1109 static inline void jpeg_dec_ll_set_reg0x1f_hufdc_len_yf(uint32_t value)
1110 {
1111 REG_WRITE(JPEG_DEC_REG0X1F_ADDR,value);
1112 }
1113
1114 /* REG_0x20 */
1115 #define JPEG_DEC_REG0X20_ADDR (JPEG_DEC_LL_REG_BASE + 0x20*4) //REG ADDR :0x48040080
1116 #define JPEG_DEC_REG0X20_HUFDC_LEN_UV0_POS (0)
1117 #define JPEG_DEC_REG0X20_HUFDC_LEN_UV0_MASK (0xFFFFFFFF)
1118
jpeg_dec_ll_get_reg0x20_value(void)1119 static inline uint32_t jpeg_dec_ll_get_reg0x20_value(void)
1120 {
1121 return REG_READ(JPEG_DEC_REG0X20_ADDR);
1122 }
1123
jpeg_dec_ll_set_reg0x20_value(uint32_t value)1124 static inline void jpeg_dec_ll_set_reg0x20_value(uint32_t value)
1125 {
1126 REG_WRITE(JPEG_DEC_REG0X20_ADDR,value);
1127 }
1128
1129 /* REG_0x20:reg0x20->hufdc_len_uv0:0x20,uv huffman table dc0,0x0,R/W*/
jpeg_dec_ll_get_reg0x20_hufdc_len_uv0(void)1130 static inline uint32_t jpeg_dec_ll_get_reg0x20_hufdc_len_uv0(void)
1131 {
1132 return REG_READ(JPEG_DEC_REG0X20_ADDR);
1133 }
1134
jpeg_dec_ll_set_reg0x20_hufdc_len_uv0(uint32_t value)1135 static inline void jpeg_dec_ll_set_reg0x20_hufdc_len_uv0(uint32_t value)
1136 {
1137 REG_WRITE(JPEG_DEC_REG0X20_ADDR,value);
1138 }
1139
1140 /* REG_0x21 */
1141 #define JPEG_DEC_REG0X21_ADDR (JPEG_DEC_LL_REG_BASE + 0x21*4) //REG ADDR :0x48040084
1142 #define JPEG_DEC_REG0X21_HUFDC_LEN_UV1_POS (0)
1143 #define JPEG_DEC_REG0X21_HUFDC_LEN_UV1_MASK (0xFFFFFFFF)
1144
jpeg_dec_ll_get_reg0x21_value(void)1145 static inline uint32_t jpeg_dec_ll_get_reg0x21_value(void)
1146 {
1147 return REG_READ(JPEG_DEC_REG0X21_ADDR);
1148 }
1149
jpeg_dec_ll_set_reg0x21_value(uint32_t value)1150 static inline void jpeg_dec_ll_set_reg0x21_value(uint32_t value)
1151 {
1152 REG_WRITE(JPEG_DEC_REG0X21_ADDR,value);
1153 }
1154
1155 /* REG_0x21:reg0x21->hufdc_len_uv1:0x21,uv huffman table dc1,0x0,R/W*/
jpeg_dec_ll_get_reg0x21_hufdc_len_uv1(void)1156 static inline uint32_t jpeg_dec_ll_get_reg0x21_hufdc_len_uv1(void)
1157 {
1158 return REG_READ(JPEG_DEC_REG0X21_ADDR);
1159 }
1160
jpeg_dec_ll_set_reg0x21_hufdc_len_uv1(uint32_t value)1161 static inline void jpeg_dec_ll_set_reg0x21_hufdc_len_uv1(uint32_t value)
1162 {
1163 REG_WRITE(JPEG_DEC_REG0X21_ADDR,value);
1164 }
1165
1166 /* REG_0x22 */
1167 #define JPEG_DEC_REG0X22_ADDR (JPEG_DEC_LL_REG_BASE + 0x22*4) //REG ADDR :0x48040088
1168 #define JPEG_DEC_REG0X22_HUFDC_LEN_UV2_POS (0)
1169 #define JPEG_DEC_REG0X22_HUFDC_LEN_UV2_MASK (0xFFFFFFFF)
1170
jpeg_dec_ll_get_reg0x22_value(void)1171 static inline uint32_t jpeg_dec_ll_get_reg0x22_value(void)
1172 {
1173 return REG_READ(JPEG_DEC_REG0X22_ADDR);
1174 }
1175
jpeg_dec_ll_set_reg0x22_value(uint32_t value)1176 static inline void jpeg_dec_ll_set_reg0x22_value(uint32_t value)
1177 {
1178 REG_WRITE(JPEG_DEC_REG0X22_ADDR,value);
1179 }
1180
1181 /* REG_0x22:reg0x22->hufdc_len_uv2:0x22,uv huffman table dc2,0x0,R/W*/
jpeg_dec_ll_get_reg0x22_hufdc_len_uv2(void)1182 static inline uint32_t jpeg_dec_ll_get_reg0x22_hufdc_len_uv2(void)
1183 {
1184 return REG_READ(JPEG_DEC_REG0X22_ADDR);
1185 }
1186
jpeg_dec_ll_set_reg0x22_hufdc_len_uv2(uint32_t value)1187 static inline void jpeg_dec_ll_set_reg0x22_hufdc_len_uv2(uint32_t value)
1188 {
1189 REG_WRITE(JPEG_DEC_REG0X22_ADDR,value);
1190 }
1191
1192 /* REG_0x23 */
1193 #define JPEG_DEC_REG0X23_ADDR (JPEG_DEC_LL_REG_BASE + 0x23*4) //REG ADDR :0x4804008c
1194 #define JPEG_DEC_REG0X23_HUFDC_LEN_UV3_POS (0)
1195 #define JPEG_DEC_REG0X23_HUFDC_LEN_UV3_MASK (0xFFFFFFFF)
1196
jpeg_dec_ll_get_reg0x23_value(void)1197 static inline uint32_t jpeg_dec_ll_get_reg0x23_value(void)
1198 {
1199 return REG_READ(JPEG_DEC_REG0X23_ADDR);
1200 }
1201
jpeg_dec_ll_set_reg0x23_value(uint32_t value)1202 static inline void jpeg_dec_ll_set_reg0x23_value(uint32_t value)
1203 {
1204 REG_WRITE(JPEG_DEC_REG0X23_ADDR,value);
1205 }
1206
1207 /* REG_0x23:reg0x23->hufdc_len_uv3:0x23,uv huffman table dc3,0x0,R/W*/
jpeg_dec_ll_get_reg0x23_hufdc_len_uv3(void)1208 static inline uint32_t jpeg_dec_ll_get_reg0x23_hufdc_len_uv3(void)
1209 {
1210 return REG_READ(JPEG_DEC_REG0X23_ADDR);
1211 }
1212
jpeg_dec_ll_set_reg0x23_hufdc_len_uv3(uint32_t value)1213 static inline void jpeg_dec_ll_set_reg0x23_hufdc_len_uv3(uint32_t value)
1214 {
1215 REG_WRITE(JPEG_DEC_REG0X23_ADDR,value);
1216 }
1217
1218 /* REG_0x24 */
1219 #define JPEG_DEC_REG0X24_ADDR (JPEG_DEC_LL_REG_BASE + 0x24*4) //REG ADDR :0x48040090
1220 #define JPEG_DEC_REG0X24_HUFDC_LEN_UV4_POS (0)
1221 #define JPEG_DEC_REG0X24_HUFDC_LEN_UV4_MASK (0xFFFFFFFF)
1222
jpeg_dec_ll_get_reg0x24_value(void)1223 static inline uint32_t jpeg_dec_ll_get_reg0x24_value(void)
1224 {
1225 return REG_READ(JPEG_DEC_REG0X24_ADDR);
1226 }
1227
jpeg_dec_ll_set_reg0x24_value(uint32_t value)1228 static inline void jpeg_dec_ll_set_reg0x24_value(uint32_t value)
1229 {
1230 REG_WRITE(JPEG_DEC_REG0X24_ADDR,value);
1231 }
1232
1233 /* REG_0x24:reg0x24->hufdc_len_uv4:0x24,uv huffman table dc4,0x0,R/W*/
jpeg_dec_ll_get_reg0x24_hufdc_len_uv4(void)1234 static inline uint32_t jpeg_dec_ll_get_reg0x24_hufdc_len_uv4(void)
1235 {
1236 return REG_READ(JPEG_DEC_REG0X24_ADDR);
1237 }
1238
jpeg_dec_ll_set_reg0x24_hufdc_len_uv4(uint32_t value)1239 static inline void jpeg_dec_ll_set_reg0x24_hufdc_len_uv4(uint32_t value)
1240 {
1241 REG_WRITE(JPEG_DEC_REG0X24_ADDR,value);
1242 }
1243
1244 /* REG_0x25 */
1245 #define JPEG_DEC_REG0X25_ADDR (JPEG_DEC_LL_REG_BASE + 0x25*4) //REG ADDR :0x48040094
1246 #define JPEG_DEC_REG0X25_HUFDC_LEN_UV5_POS (0)
1247 #define JPEG_DEC_REG0X25_HUFDC_LEN_UV5_MASK (0xFFFFFFFF)
1248
jpeg_dec_ll_get_reg0x25_value(void)1249 static inline uint32_t jpeg_dec_ll_get_reg0x25_value(void)
1250 {
1251 return REG_READ(JPEG_DEC_REG0X25_ADDR);
1252 }
1253
jpeg_dec_ll_set_reg0x25_value(uint32_t value)1254 static inline void jpeg_dec_ll_set_reg0x25_value(uint32_t value)
1255 {
1256 REG_WRITE(JPEG_DEC_REG0X25_ADDR,value);
1257 }
1258
1259 /* REG_0x25:reg0x25->hufdc_len_uv5:0x25,uv huffman table dc5,0x0,R/W*/
jpeg_dec_ll_get_reg0x25_hufdc_len_uv5(void)1260 static inline uint32_t jpeg_dec_ll_get_reg0x25_hufdc_len_uv5(void)
1261 {
1262 return REG_READ(JPEG_DEC_REG0X25_ADDR);
1263 }
1264
jpeg_dec_ll_set_reg0x25_hufdc_len_uv5(uint32_t value)1265 static inline void jpeg_dec_ll_set_reg0x25_hufdc_len_uv5(uint32_t value)
1266 {
1267 REG_WRITE(JPEG_DEC_REG0X25_ADDR,value);
1268 }
1269
1270 /* REG_0x26 */
1271 #define JPEG_DEC_REG0X26_ADDR (JPEG_DEC_LL_REG_BASE + 0x26*4) //REG ADDR :0x48040098
1272 #define JPEG_DEC_REG0X26_HUFDC_LEN_UV6_POS (0)
1273 #define JPEG_DEC_REG0X26_HUFDC_LEN_UV6_MASK (0xFFFFFFFF)
1274
jpeg_dec_ll_get_reg0x26_value(void)1275 static inline uint32_t jpeg_dec_ll_get_reg0x26_value(void)
1276 {
1277 return REG_READ(JPEG_DEC_REG0X26_ADDR);
1278 }
1279
jpeg_dec_ll_set_reg0x26_value(uint32_t value)1280 static inline void jpeg_dec_ll_set_reg0x26_value(uint32_t value)
1281 {
1282 REG_WRITE(JPEG_DEC_REG0X26_ADDR,value);
1283 }
1284
1285 /* REG_0x26:reg0x26->hufdc_len_uv6:0x26,uv huffman table dc6,0x0,R/W*/
jpeg_dec_ll_get_reg0x26_hufdc_len_uv6(void)1286 static inline uint32_t jpeg_dec_ll_get_reg0x26_hufdc_len_uv6(void)
1287 {
1288 return REG_READ(JPEG_DEC_REG0X26_ADDR);
1289 }
1290
jpeg_dec_ll_set_reg0x26_hufdc_len_uv6(uint32_t value)1291 static inline void jpeg_dec_ll_set_reg0x26_hufdc_len_uv6(uint32_t value)
1292 {
1293 REG_WRITE(JPEG_DEC_REG0X26_ADDR,value);
1294 }
1295
1296 /* REG_0x27 */
1297 #define JPEG_DEC_REG0X27_ADDR (JPEG_DEC_LL_REG_BASE + 0x27*4) //REG ADDR :0x4804009c
1298 #define JPEG_DEC_REG0X27_HUFDC_LEN_UV7_POS (0)
1299 #define JPEG_DEC_REG0X27_HUFDC_LEN_UV7_MASK (0xFFFFFFFF)
1300
jpeg_dec_ll_get_reg0x27_value(void)1301 static inline uint32_t jpeg_dec_ll_get_reg0x27_value(void)
1302 {
1303 return REG_READ(JPEG_DEC_REG0X27_ADDR);
1304 }
1305
jpeg_dec_ll_set_reg0x27_value(uint32_t value)1306 static inline void jpeg_dec_ll_set_reg0x27_value(uint32_t value)
1307 {
1308 REG_WRITE(JPEG_DEC_REG0X27_ADDR,value);
1309 }
1310
1311 /* REG_0x27:reg0x27->hufdc_len_uv7:0x27,uv huffman table dc7,0x0,R/W*/
jpeg_dec_ll_get_reg0x27_hufdc_len_uv7(void)1312 static inline uint32_t jpeg_dec_ll_get_reg0x27_hufdc_len_uv7(void)
1313 {
1314 return REG_READ(JPEG_DEC_REG0X27_ADDR);
1315 }
1316
jpeg_dec_ll_set_reg0x27_hufdc_len_uv7(uint32_t value)1317 static inline void jpeg_dec_ll_set_reg0x27_hufdc_len_uv7(uint32_t value)
1318 {
1319 REG_WRITE(JPEG_DEC_REG0X27_ADDR,value);
1320 }
1321
1322 /* REG_0x28 */
1323 #define JPEG_DEC_REG0X28_ADDR (JPEG_DEC_LL_REG_BASE + 0x28*4) //REG ADDR :0x480400a0
1324 #define JPEG_DEC_REG0X28_HUFDC_LEN_UV8_POS (0)
1325 #define JPEG_DEC_REG0X28_HUFDC_LEN_UV8_MASK (0xFFFFFFFF)
1326
jpeg_dec_ll_get_reg0x28_value(void)1327 static inline uint32_t jpeg_dec_ll_get_reg0x28_value(void)
1328 {
1329 return REG_READ(JPEG_DEC_REG0X28_ADDR);
1330 }
1331
jpeg_dec_ll_set_reg0x28_value(uint32_t value)1332 static inline void jpeg_dec_ll_set_reg0x28_value(uint32_t value)
1333 {
1334 REG_WRITE(JPEG_DEC_REG0X28_ADDR,value);
1335 }
1336
1337 /* REG_0x28:reg0x28->hufdc_len_uv8:0x28,uv huffman table dc8,0x0,R/W*/
jpeg_dec_ll_get_reg0x28_hufdc_len_uv8(void)1338 static inline uint32_t jpeg_dec_ll_get_reg0x28_hufdc_len_uv8(void)
1339 {
1340 return REG_READ(JPEG_DEC_REG0X28_ADDR);
1341 }
1342
jpeg_dec_ll_set_reg0x28_hufdc_len_uv8(uint32_t value)1343 static inline void jpeg_dec_ll_set_reg0x28_hufdc_len_uv8(uint32_t value)
1344 {
1345 REG_WRITE(JPEG_DEC_REG0X28_ADDR,value);
1346 }
1347
1348 /* REG_0x29 */
1349 #define JPEG_DEC_REG0X29_ADDR (JPEG_DEC_LL_REG_BASE + 0x29*4) //REG ADDR :0x480400a4
1350 #define JPEG_DEC_REG0X29_HUFDC_LEN_UV9_POS (0)
1351 #define JPEG_DEC_REG0X29_HUFDC_LEN_UV9_MASK (0xFFFFFFFF)
1352
jpeg_dec_ll_get_reg0x29_value(void)1353 static inline uint32_t jpeg_dec_ll_get_reg0x29_value(void)
1354 {
1355 return REG_READ(JPEG_DEC_REG0X29_ADDR);
1356 }
1357
jpeg_dec_ll_set_reg0x29_value(uint32_t value)1358 static inline void jpeg_dec_ll_set_reg0x29_value(uint32_t value)
1359 {
1360 REG_WRITE(JPEG_DEC_REG0X29_ADDR,value);
1361 }
1362
1363 /* REG_0x29:reg0x29->hufdc_len_uv9:0x29,uv huffman table dc9,0x0,R/W*/
jpeg_dec_ll_get_reg0x29_hufdc_len_uv9(void)1364 static inline uint32_t jpeg_dec_ll_get_reg0x29_hufdc_len_uv9(void)
1365 {
1366 return REG_READ(JPEG_DEC_REG0X29_ADDR);
1367 }
1368
jpeg_dec_ll_set_reg0x29_hufdc_len_uv9(uint32_t value)1369 static inline void jpeg_dec_ll_set_reg0x29_hufdc_len_uv9(uint32_t value)
1370 {
1371 REG_WRITE(JPEG_DEC_REG0X29_ADDR,value);
1372 }
1373
1374 /* REG_0x2A */
1375 #define JPEG_DEC_REG0X2A_ADDR (JPEG_DEC_LL_REG_BASE + 0x2A*4) //REG ADDR :0x480400a8
1376 #define JPEG_DEC_REG0X2A_HUFDC_LEN_UVA_POS (0)
1377 #define JPEG_DEC_REG0X2A_HUFDC_LEN_UVA_MASK (0xFFFFFFFF)
1378
jpeg_dec_ll_get_reg0x2a_value(void)1379 static inline uint32_t jpeg_dec_ll_get_reg0x2a_value(void)
1380 {
1381 return REG_READ(JPEG_DEC_REG0X2A_ADDR);
1382 }
1383
jpeg_dec_ll_set_reg0x2a_value(uint32_t value)1384 static inline void jpeg_dec_ll_set_reg0x2a_value(uint32_t value)
1385 {
1386 REG_WRITE(JPEG_DEC_REG0X2A_ADDR,value);
1387 }
1388
1389 /* REG_0x2a:reg0x2a->hufdc_len_uva:0x2a,uv huffman table dca,0x0,R/W*/
jpeg_dec_ll_get_reg0x2a_hufdc_len_uva(void)1390 static inline uint32_t jpeg_dec_ll_get_reg0x2a_hufdc_len_uva(void)
1391 {
1392 return REG_READ(JPEG_DEC_REG0X2A_ADDR);
1393 }
1394
jpeg_dec_ll_set_reg0x2a_hufdc_len_uva(uint32_t value)1395 static inline void jpeg_dec_ll_set_reg0x2a_hufdc_len_uva(uint32_t value)
1396 {
1397 REG_WRITE(JPEG_DEC_REG0X2A_ADDR,value);
1398 }
1399
1400 /* REG_0x2B */
1401 #define JPEG_DEC_REG0X2B_ADDR (JPEG_DEC_LL_REG_BASE + 0x2B*4) //REG ADDR :0x480400ac
1402 #define JPEG_DEC_REG0X2B_HUFDC_LEN_UVB_POS (0)
1403 #define JPEG_DEC_REG0X2B_HUFDC_LEN_UVB_MASK (0xFFFFFFFF)
1404
jpeg_dec_ll_get_reg0x2b_value(void)1405 static inline uint32_t jpeg_dec_ll_get_reg0x2b_value(void)
1406 {
1407 return REG_READ(JPEG_DEC_REG0X2B_ADDR);
1408 }
1409
jpeg_dec_ll_set_reg0x2b_value(uint32_t value)1410 static inline void jpeg_dec_ll_set_reg0x2b_value(uint32_t value)
1411 {
1412 REG_WRITE(JPEG_DEC_REG0X2B_ADDR,value);
1413 }
1414
1415 /* REG_0x2b:reg0x2b->hufdc_len_uvb:0x2b,uv huffman table dcb,0x0,R/W*/
jpeg_dec_ll_get_reg0x2b_hufdc_len_uvb(void)1416 static inline uint32_t jpeg_dec_ll_get_reg0x2b_hufdc_len_uvb(void)
1417 {
1418 return REG_READ(JPEG_DEC_REG0X2B_ADDR);
1419 }
1420
jpeg_dec_ll_set_reg0x2b_hufdc_len_uvb(uint32_t value)1421 static inline void jpeg_dec_ll_set_reg0x2b_hufdc_len_uvb(uint32_t value)
1422 {
1423 REG_WRITE(JPEG_DEC_REG0X2B_ADDR,value);
1424 }
1425
1426 /* REG_0x2C */
1427 #define JPEG_DEC_REG0X2C_ADDR (JPEG_DEC_LL_REG_BASE + 0x2C*4) //REG ADDR :0x480400b0
1428 #define JPEG_DEC_REG0X2C_HUFDC_LEN_UVC_POS (0)
1429 #define JPEG_DEC_REG0X2C_HUFDC_LEN_UVC_MASK (0xFFFFFFFF)
1430
jpeg_dec_ll_get_reg0x2c_value(void)1431 static inline uint32_t jpeg_dec_ll_get_reg0x2c_value(void)
1432 {
1433 return REG_READ(JPEG_DEC_REG0X2C_ADDR);
1434 }
1435
jpeg_dec_ll_set_reg0x2c_value(uint32_t value)1436 static inline void jpeg_dec_ll_set_reg0x2c_value(uint32_t value)
1437 {
1438 REG_WRITE(JPEG_DEC_REG0X2C_ADDR,value);
1439 }
1440
1441 /* REG_0x2c:reg0x2c->hufdc_len_uvc:0x2c,uv huffman table dcc,0x0,R/W*/
jpeg_dec_ll_get_reg0x2c_hufdc_len_uvc(void)1442 static inline uint32_t jpeg_dec_ll_get_reg0x2c_hufdc_len_uvc(void)
1443 {
1444 return REG_READ(JPEG_DEC_REG0X2C_ADDR);
1445 }
1446
jpeg_dec_ll_set_reg0x2c_hufdc_len_uvc(uint32_t value)1447 static inline void jpeg_dec_ll_set_reg0x2c_hufdc_len_uvc(uint32_t value)
1448 {
1449 REG_WRITE(JPEG_DEC_REG0X2C_ADDR,value);
1450 }
1451
1452 /* REG_0x2D */
1453 #define JPEG_DEC_REG0X2D_ADDR (JPEG_DEC_LL_REG_BASE + 0x2D*4) //REG ADDR :0x480400b4
1454 #define JPEG_DEC_REG0X2D_HUFDC_LEN_UVD_POS (0)
1455 #define JPEG_DEC_REG0X2D_HUFDC_LEN_UVD_MASK (0xFFFFFFFF)
1456
jpeg_dec_ll_get_reg0x2d_value(void)1457 static inline uint32_t jpeg_dec_ll_get_reg0x2d_value(void)
1458 {
1459 return REG_READ(JPEG_DEC_REG0X2D_ADDR);
1460 }
1461
jpeg_dec_ll_set_reg0x2d_value(uint32_t value)1462 static inline void jpeg_dec_ll_set_reg0x2d_value(uint32_t value)
1463 {
1464 REG_WRITE(JPEG_DEC_REG0X2D_ADDR,value);
1465 }
1466
1467 /* REG_0x2d:reg0x2d->hufdc_len_uvd:0x2d,uv huffman table dcd,0x0,R/W*/
jpeg_dec_ll_get_reg0x2d_hufdc_len_uvd(void)1468 static inline uint32_t jpeg_dec_ll_get_reg0x2d_hufdc_len_uvd(void)
1469 {
1470 return REG_READ(JPEG_DEC_REG0X2D_ADDR);
1471 }
1472
jpeg_dec_ll_set_reg0x2d_hufdc_len_uvd(uint32_t value)1473 static inline void jpeg_dec_ll_set_reg0x2d_hufdc_len_uvd(uint32_t value)
1474 {
1475 REG_WRITE(JPEG_DEC_REG0X2D_ADDR,value);
1476 }
1477
1478 /* REG_0x2E */
1479 #define JPEG_DEC_REG0X2E_ADDR (JPEG_DEC_LL_REG_BASE + 0x2E*4) //REG ADDR :0x480400b8
1480 #define JPEG_DEC_REG0X2E_HUFDC_LEN_UVE_POS (0)
1481 #define JPEG_DEC_REG0X2E_HUFDC_LEN_UVE_MASK (0xFFFFFFFF)
1482
jpeg_dec_ll_get_reg0x2e_value(void)1483 static inline uint32_t jpeg_dec_ll_get_reg0x2e_value(void)
1484 {
1485 return REG_READ(JPEG_DEC_REG0X2E_ADDR);
1486 }
1487
jpeg_dec_ll_set_reg0x2e_value(uint32_t value)1488 static inline void jpeg_dec_ll_set_reg0x2e_value(uint32_t value)
1489 {
1490 REG_WRITE(JPEG_DEC_REG0X2E_ADDR,value);
1491 }
1492
1493 /* REG_0x2e:reg0x2e->hufdc_len_uve:0x2e,uv huffman table dce,0x0,R/W*/
jpeg_dec_ll_get_reg0x2e_hufdc_len_uve(void)1494 static inline uint32_t jpeg_dec_ll_get_reg0x2e_hufdc_len_uve(void)
1495 {
1496 return REG_READ(JPEG_DEC_REG0X2E_ADDR);
1497 }
1498
jpeg_dec_ll_set_reg0x2e_hufdc_len_uve(uint32_t value)1499 static inline void jpeg_dec_ll_set_reg0x2e_hufdc_len_uve(uint32_t value)
1500 {
1501 REG_WRITE(JPEG_DEC_REG0X2E_ADDR,value);
1502 }
1503
1504 /* REG_0x2F */
1505 #define JPEG_DEC_REG0X2F_ADDR (JPEG_DEC_LL_REG_BASE + 0x2F*4) //REG ADDR :0x480400bc
1506 #define JPEG_DEC_REG0X2F_HUFDC_LEN_UVF_POS (0)
1507 #define JPEG_DEC_REG0X2F_HUFDC_LEN_UVF_MASK (0xFFFFFFFF)
1508
jpeg_dec_ll_get_reg0x2f_value(void)1509 static inline uint32_t jpeg_dec_ll_get_reg0x2f_value(void)
1510 {
1511 return REG_READ(JPEG_DEC_REG0X2F_ADDR);
1512 }
1513
jpeg_dec_ll_set_reg0x2f_value(uint32_t value)1514 static inline void jpeg_dec_ll_set_reg0x2f_value(uint32_t value)
1515 {
1516 REG_WRITE(JPEG_DEC_REG0X2F_ADDR,value);
1517 }
1518
1519 /* REG_0x2f:reg0x2f->hufdc_len_uvf:0x2f,uv huffman table dcf,0x0,R/W*/
jpeg_dec_ll_get_reg0x2f_hufdc_len_uvf(void)1520 static inline uint32_t jpeg_dec_ll_get_reg0x2f_hufdc_len_uvf(void)
1521 {
1522 return REG_READ(JPEG_DEC_REG0X2F_ADDR);
1523 }
1524
jpeg_dec_ll_set_reg0x2f_hufdc_len_uvf(uint32_t value)1525 static inline void jpeg_dec_ll_set_reg0x2f_hufdc_len_uvf(uint32_t value)
1526 {
1527 REG_WRITE(JPEG_DEC_REG0X2F_ADDR,value);
1528 }
1529
1530 /* REG_0x30 */
1531 #define JPEG_DEC_REG0X30_ADDR (JPEG_DEC_LL_REG_BASE + 0x30*4) //REG ADDR :0x480400c0
1532 #define JPEG_DEC_REG0X30_HUFAC_LEN_Y0_POS (0)
1533 #define JPEG_DEC_REG0X30_HUFAC_LEN_Y0_MASK (0xFFFFFFFF)
1534
jpeg_dec_ll_get_reg0x30_value(void)1535 static inline uint32_t jpeg_dec_ll_get_reg0x30_value(void)
1536 {
1537 return REG_READ(JPEG_DEC_REG0X30_ADDR);
1538 }
1539
jpeg_dec_ll_set_reg0x30_value(uint32_t value)1540 static inline void jpeg_dec_ll_set_reg0x30_value(uint32_t value)
1541 {
1542 REG_WRITE(JPEG_DEC_REG0X30_ADDR,value);
1543 }
1544
1545 /* REG_0x30:reg0x30->hufac_len_y0:0x30,y huffman table ac0,0x0,R/W*/
jpeg_dec_ll_get_reg0x30_hufac_len_y0(void)1546 static inline uint32_t jpeg_dec_ll_get_reg0x30_hufac_len_y0(void)
1547 {
1548 return REG_READ(JPEG_DEC_REG0X30_ADDR);
1549 }
1550
jpeg_dec_ll_set_reg0x30_hufac_len_y0(uint32_t value)1551 static inline void jpeg_dec_ll_set_reg0x30_hufac_len_y0(uint32_t value)
1552 {
1553 REG_WRITE(JPEG_DEC_REG0X30_ADDR,value);
1554 }
1555
1556 /* REG_0x31 */
1557 #define JPEG_DEC_REG0X31_ADDR (JPEG_DEC_LL_REG_BASE + 0x31*4) //REG ADDR :0x480400c4
1558 #define JPEG_DEC_REG0X31_HUFAC_LEN_Y1_POS (0)
1559 #define JPEG_DEC_REG0X31_HUFAC_LEN_Y1_MASK (0xFFFFFFFF)
1560
jpeg_dec_ll_get_reg0x31_value(void)1561 static inline uint32_t jpeg_dec_ll_get_reg0x31_value(void)
1562 {
1563 return REG_READ(JPEG_DEC_REG0X31_ADDR);
1564 }
1565
jpeg_dec_ll_set_reg0x31_value(uint32_t value)1566 static inline void jpeg_dec_ll_set_reg0x31_value(uint32_t value)
1567 {
1568 REG_WRITE(JPEG_DEC_REG0X31_ADDR,value);
1569 }
1570
1571 /* REG_0x31:reg0x31->hufac_len_y1:0x31,y huffman table ac1,0x0,R/W*/
jpeg_dec_ll_get_reg0x31_hufac_len_y1(void)1572 static inline uint32_t jpeg_dec_ll_get_reg0x31_hufac_len_y1(void)
1573 {
1574 return REG_READ(JPEG_DEC_REG0X31_ADDR);
1575 }
1576
jpeg_dec_ll_set_reg0x31_hufac_len_y1(uint32_t value)1577 static inline void jpeg_dec_ll_set_reg0x31_hufac_len_y1(uint32_t value)
1578 {
1579 REG_WRITE(JPEG_DEC_REG0X31_ADDR,value);
1580 }
1581
1582 /* REG_0x32 */
1583 #define JPEG_DEC_REG0X32_ADDR (JPEG_DEC_LL_REG_BASE + 0x32*4) //REG ADDR :0x480400c8
1584 #define JPEG_DEC_REG0X32_HUFAC_LEN_Y2_POS (0)
1585 #define JPEG_DEC_REG0X32_HUFAC_LEN_Y2_MASK (0xFFFFFFFF)
1586
jpeg_dec_ll_get_reg0x32_value(void)1587 static inline uint32_t jpeg_dec_ll_get_reg0x32_value(void)
1588 {
1589 return REG_READ(JPEG_DEC_REG0X32_ADDR);
1590 }
1591
jpeg_dec_ll_set_reg0x32_value(uint32_t value)1592 static inline void jpeg_dec_ll_set_reg0x32_value(uint32_t value)
1593 {
1594 REG_WRITE(JPEG_DEC_REG0X32_ADDR,value);
1595 }
1596
1597 /* REG_0x32:reg0x32->hufac_len_y2:0x32,y huffman table ac2,0x0,R/W*/
jpeg_dec_ll_get_reg0x32_hufac_len_y2(void)1598 static inline uint32_t jpeg_dec_ll_get_reg0x32_hufac_len_y2(void)
1599 {
1600 return REG_READ(JPEG_DEC_REG0X32_ADDR);
1601 }
1602
jpeg_dec_ll_set_reg0x32_hufac_len_y2(uint32_t value)1603 static inline void jpeg_dec_ll_set_reg0x32_hufac_len_y2(uint32_t value)
1604 {
1605 REG_WRITE(JPEG_DEC_REG0X32_ADDR,value);
1606 }
1607
1608 /* REG_0x33 */
1609 #define JPEG_DEC_REG0X33_ADDR (JPEG_DEC_LL_REG_BASE + 0x33*4) //REG ADDR :0x480400cc
1610 #define JPEG_DEC_REG0X33_HUFAC_LEN_Y3_POS (0)
1611 #define JPEG_DEC_REG0X33_HUFAC_LEN_Y3_MASK (0xFFFFFFFF)
1612
jpeg_dec_ll_get_reg0x33_value(void)1613 static inline uint32_t jpeg_dec_ll_get_reg0x33_value(void)
1614 {
1615 return REG_READ(JPEG_DEC_REG0X33_ADDR);
1616 }
1617
jpeg_dec_ll_set_reg0x33_value(uint32_t value)1618 static inline void jpeg_dec_ll_set_reg0x33_value(uint32_t value)
1619 {
1620 REG_WRITE(JPEG_DEC_REG0X33_ADDR,value);
1621 }
1622
1623 /* REG_0x33:reg0x33->hufac_len_y3:0x33,y huffman table ac3,0x0,R/W*/
jpeg_dec_ll_get_reg0x33_hufac_len_y3(void)1624 static inline uint32_t jpeg_dec_ll_get_reg0x33_hufac_len_y3(void)
1625 {
1626 return REG_READ(JPEG_DEC_REG0X33_ADDR);
1627 }
1628
jpeg_dec_ll_set_reg0x33_hufac_len_y3(uint32_t value)1629 static inline void jpeg_dec_ll_set_reg0x33_hufac_len_y3(uint32_t value)
1630 {
1631 REG_WRITE(JPEG_DEC_REG0X33_ADDR,value);
1632 }
1633
1634 /* REG_0x34 */
1635 #define JPEG_DEC_REG0X34_ADDR (JPEG_DEC_LL_REG_BASE + 0x34*4) //REG ADDR :0x480400d0
1636 #define JPEG_DEC_REG0X34_HUFAC_LEN_Y4_POS (0)
1637 #define JPEG_DEC_REG0X34_HUFAC_LEN_Y4_MASK (0xFFFFFFFF)
1638
jpeg_dec_ll_get_reg0x34_value(void)1639 static inline uint32_t jpeg_dec_ll_get_reg0x34_value(void)
1640 {
1641 return REG_READ(JPEG_DEC_REG0X34_ADDR);
1642 }
1643
jpeg_dec_ll_set_reg0x34_value(uint32_t value)1644 static inline void jpeg_dec_ll_set_reg0x34_value(uint32_t value)
1645 {
1646 REG_WRITE(JPEG_DEC_REG0X34_ADDR,value);
1647 }
1648
1649 /* REG_0x34:reg0x34->hufac_len_y4:0x34,y huffman table ac4,0x0,R/W*/
jpeg_dec_ll_get_reg0x34_hufac_len_y4(void)1650 static inline uint32_t jpeg_dec_ll_get_reg0x34_hufac_len_y4(void)
1651 {
1652 return REG_READ(JPEG_DEC_REG0X34_ADDR);
1653 }
1654
jpeg_dec_ll_set_reg0x34_hufac_len_y4(uint32_t value)1655 static inline void jpeg_dec_ll_set_reg0x34_hufac_len_y4(uint32_t value)
1656 {
1657 REG_WRITE(JPEG_DEC_REG0X34_ADDR,value);
1658 }
1659
1660 /* REG_0x35 */
1661 #define JPEG_DEC_REG0X35_ADDR (JPEG_DEC_LL_REG_BASE + 0x35*4) //REG ADDR :0x480400d4
1662 #define JPEG_DEC_REG0X35_HUFAC_LEN_Y5_POS (0)
1663 #define JPEG_DEC_REG0X35_HUFAC_LEN_Y5_MASK (0xFFFFFFFF)
1664
jpeg_dec_ll_get_reg0x35_value(void)1665 static inline uint32_t jpeg_dec_ll_get_reg0x35_value(void)
1666 {
1667 return REG_READ(JPEG_DEC_REG0X35_ADDR);
1668 }
1669
jpeg_dec_ll_set_reg0x35_value(uint32_t value)1670 static inline void jpeg_dec_ll_set_reg0x35_value(uint32_t value)
1671 {
1672 REG_WRITE(JPEG_DEC_REG0X35_ADDR,value);
1673 }
1674
1675 /* REG_0x35:reg0x35->hufac_len_y5:0x35,y huffman table ac5,0x0,R/W*/
jpeg_dec_ll_get_reg0x35_hufac_len_y5(void)1676 static inline uint32_t jpeg_dec_ll_get_reg0x35_hufac_len_y5(void)
1677 {
1678 return REG_READ(JPEG_DEC_REG0X35_ADDR);
1679 }
1680
jpeg_dec_ll_set_reg0x35_hufac_len_y5(uint32_t value)1681 static inline void jpeg_dec_ll_set_reg0x35_hufac_len_y5(uint32_t value)
1682 {
1683 REG_WRITE(JPEG_DEC_REG0X35_ADDR,value);
1684 }
1685
1686 /* REG_0x36 */
1687 #define JPEG_DEC_REG0X36_ADDR (JPEG_DEC_LL_REG_BASE + 0x36*4) //REG ADDR :0x480400d8
1688 #define JPEG_DEC_REG0X36_HUFAC_LEN_Y6_POS (0)
1689 #define JPEG_DEC_REG0X36_HUFAC_LEN_Y6_MASK (0xFFFFFFFF)
1690
jpeg_dec_ll_get_reg0x36_value(void)1691 static inline uint32_t jpeg_dec_ll_get_reg0x36_value(void)
1692 {
1693 return REG_READ(JPEG_DEC_REG0X36_ADDR);
1694 }
1695
jpeg_dec_ll_set_reg0x36_value(uint32_t value)1696 static inline void jpeg_dec_ll_set_reg0x36_value(uint32_t value)
1697 {
1698 REG_WRITE(JPEG_DEC_REG0X36_ADDR,value);
1699 }
1700
1701 /* REG_0x36:reg0x36->hufac_len_y6:0x36,y huffman table ac6,0x0,R/W*/
jpeg_dec_ll_get_reg0x36_hufac_len_y6(void)1702 static inline uint32_t jpeg_dec_ll_get_reg0x36_hufac_len_y6(void)
1703 {
1704 return REG_READ(JPEG_DEC_REG0X36_ADDR);
1705 }
1706
jpeg_dec_ll_set_reg0x36_hufac_len_y6(uint32_t value)1707 static inline void jpeg_dec_ll_set_reg0x36_hufac_len_y6(uint32_t value)
1708 {
1709 REG_WRITE(JPEG_DEC_REG0X36_ADDR,value);
1710 }
1711
1712 /* REG_0x37 */
1713 #define JPEG_DEC_REG0X37_ADDR (JPEG_DEC_LL_REG_BASE + 0x37*4) //REG ADDR :0x480400dc
1714 #define JPEG_DEC_REG0X37_HUFAC_LEN_Y7_POS (0)
1715 #define JPEG_DEC_REG0X37_HUFAC_LEN_Y7_MASK (0xFFFFFFFF)
1716
jpeg_dec_ll_get_reg0x37_value(void)1717 static inline uint32_t jpeg_dec_ll_get_reg0x37_value(void)
1718 {
1719 return REG_READ(JPEG_DEC_REG0X37_ADDR);
1720 }
1721
jpeg_dec_ll_set_reg0x37_value(uint32_t value)1722 static inline void jpeg_dec_ll_set_reg0x37_value(uint32_t value)
1723 {
1724 REG_WRITE(JPEG_DEC_REG0X37_ADDR,value);
1725 }
1726
1727 /* REG_0x37:reg0x37->hufac_len_y7:0x37,y huffman table ac7,0x0,R/W*/
jpeg_dec_ll_get_reg0x37_hufac_len_y7(void)1728 static inline uint32_t jpeg_dec_ll_get_reg0x37_hufac_len_y7(void)
1729 {
1730 return REG_READ(JPEG_DEC_REG0X37_ADDR);
1731 }
1732
jpeg_dec_ll_set_reg0x37_hufac_len_y7(uint32_t value)1733 static inline void jpeg_dec_ll_set_reg0x37_hufac_len_y7(uint32_t value)
1734 {
1735 REG_WRITE(JPEG_DEC_REG0X37_ADDR,value);
1736 }
1737
1738 /* REG_0x38 */
1739 #define JPEG_DEC_REG0X38_ADDR (JPEG_DEC_LL_REG_BASE + 0x38*4) //REG ADDR :0x480400e0
1740 #define JPEG_DEC_REG0X38_HUFAC_LEN_Y8_POS (0)
1741 #define JPEG_DEC_REG0X38_HUFAC_LEN_Y8_MASK (0xFFFFFFFF)
1742
jpeg_dec_ll_get_reg0x38_value(void)1743 static inline uint32_t jpeg_dec_ll_get_reg0x38_value(void)
1744 {
1745 return REG_READ(JPEG_DEC_REG0X38_ADDR);
1746 }
1747
jpeg_dec_ll_set_reg0x38_value(uint32_t value)1748 static inline void jpeg_dec_ll_set_reg0x38_value(uint32_t value)
1749 {
1750 REG_WRITE(JPEG_DEC_REG0X38_ADDR,value);
1751 }
1752
1753 /* REG_0x38:reg0x38->hufac_len_y8:0x38,y huffman table ac8,0x0,R/W*/
jpeg_dec_ll_get_reg0x38_hufac_len_y8(void)1754 static inline uint32_t jpeg_dec_ll_get_reg0x38_hufac_len_y8(void)
1755 {
1756 return REG_READ(JPEG_DEC_REG0X38_ADDR);
1757 }
1758
jpeg_dec_ll_set_reg0x38_hufac_len_y8(uint32_t value)1759 static inline void jpeg_dec_ll_set_reg0x38_hufac_len_y8(uint32_t value)
1760 {
1761 REG_WRITE(JPEG_DEC_REG0X38_ADDR,value);
1762 }
1763
1764 /* REG_0x39 */
1765 #define JPEG_DEC_REG0X39_ADDR (JPEG_DEC_LL_REG_BASE + 0x39*4) //REG ADDR :0x480400e4
1766 #define JPEG_DEC_REG0X39_HUFAC_LEN_Y9_POS (0)
1767 #define JPEG_DEC_REG0X39_HUFAC_LEN_Y9_MASK (0xFFFFFFFF)
1768
jpeg_dec_ll_get_reg0x39_value(void)1769 static inline uint32_t jpeg_dec_ll_get_reg0x39_value(void)
1770 {
1771 return REG_READ(JPEG_DEC_REG0X39_ADDR);
1772 }
1773
jpeg_dec_ll_set_reg0x39_value(uint32_t value)1774 static inline void jpeg_dec_ll_set_reg0x39_value(uint32_t value)
1775 {
1776 REG_WRITE(JPEG_DEC_REG0X39_ADDR,value);
1777 }
1778
1779 /* REG_0x39:reg0x39->hufac_len_y9:0x39,y huffman table ac9,0x0,R/W*/
jpeg_dec_ll_get_reg0x39_hufac_len_y9(void)1780 static inline uint32_t jpeg_dec_ll_get_reg0x39_hufac_len_y9(void)
1781 {
1782 return REG_READ(JPEG_DEC_REG0X39_ADDR);
1783 }
1784
jpeg_dec_ll_set_reg0x39_hufac_len_y9(uint32_t value)1785 static inline void jpeg_dec_ll_set_reg0x39_hufac_len_y9(uint32_t value)
1786 {
1787 REG_WRITE(JPEG_DEC_REG0X39_ADDR,value);
1788 }
1789
1790 /* REG_0x3A */
1791 #define JPEG_DEC_REG0X3A_ADDR (JPEG_DEC_LL_REG_BASE + 0x3A*4) //REG ADDR :0x480400e8
1792 #define JPEG_DEC_REG0X3A_HUFAC_LEN_YA_POS (0)
1793 #define JPEG_DEC_REG0X3A_HUFAC_LEN_YA_MASK (0xFFFFFFFF)
1794
jpeg_dec_ll_get_reg0x3a_value(void)1795 static inline uint32_t jpeg_dec_ll_get_reg0x3a_value(void)
1796 {
1797 return REG_READ(JPEG_DEC_REG0X3A_ADDR);
1798 }
1799
jpeg_dec_ll_set_reg0x3a_value(uint32_t value)1800 static inline void jpeg_dec_ll_set_reg0x3a_value(uint32_t value)
1801 {
1802 REG_WRITE(JPEG_DEC_REG0X3A_ADDR,value);
1803 }
1804
1805 /* REG_0x3a:reg0x3a->hufac_len_ya:0x3a,y huffman table aca,0x0,R/W*/
jpeg_dec_ll_get_reg0x3a_hufac_len_ya(void)1806 static inline uint32_t jpeg_dec_ll_get_reg0x3a_hufac_len_ya(void)
1807 {
1808 return REG_READ(JPEG_DEC_REG0X3A_ADDR);
1809 }
1810
jpeg_dec_ll_set_reg0x3a_hufac_len_ya(uint32_t value)1811 static inline void jpeg_dec_ll_set_reg0x3a_hufac_len_ya(uint32_t value)
1812 {
1813 REG_WRITE(JPEG_DEC_REG0X3A_ADDR,value);
1814 }
1815
1816 /* REG_0x3B */
1817 #define JPEG_DEC_REG0X3B_ADDR (JPEG_DEC_LL_REG_BASE + 0x3B*4) //REG ADDR :0x480400ec
1818 #define JPEG_DEC_REG0X3B_HUFAC_LEN_YB_POS (0)
1819 #define JPEG_DEC_REG0X3B_HUFAC_LEN_YB_MASK (0xFFFFFFFF)
1820
jpeg_dec_ll_get_reg0x3b_value(void)1821 static inline uint32_t jpeg_dec_ll_get_reg0x3b_value(void)
1822 {
1823 return REG_READ(JPEG_DEC_REG0X3B_ADDR);
1824 }
1825
jpeg_dec_ll_set_reg0x3b_value(uint32_t value)1826 static inline void jpeg_dec_ll_set_reg0x3b_value(uint32_t value)
1827 {
1828 REG_WRITE(JPEG_DEC_REG0X3B_ADDR,value);
1829 }
1830
1831 /* REG_0x3b:reg0x3b->hufac_len_yb:0x3b,y huffman table acb,0x0,R/W*/
jpeg_dec_ll_get_reg0x3b_hufac_len_yb(void)1832 static inline uint32_t jpeg_dec_ll_get_reg0x3b_hufac_len_yb(void)
1833 {
1834 return REG_READ(JPEG_DEC_REG0X3B_ADDR);
1835 }
1836
jpeg_dec_ll_set_reg0x3b_hufac_len_yb(uint32_t value)1837 static inline void jpeg_dec_ll_set_reg0x3b_hufac_len_yb(uint32_t value)
1838 {
1839 REG_WRITE(JPEG_DEC_REG0X3B_ADDR,value);
1840 }
1841
1842 /* REG_0x3C */
1843 #define JPEG_DEC_REG0X3C_ADDR (JPEG_DEC_LL_REG_BASE + 0x3C*4) //REG ADDR :0x480400f0
1844 #define JPEG_DEC_REG0X3C_HUFAC_LEN_YC_POS (0)
1845 #define JPEG_DEC_REG0X3C_HUFAC_LEN_YC_MASK (0xFFFFFFFF)
1846
jpeg_dec_ll_get_reg0x3c_value(void)1847 static inline uint32_t jpeg_dec_ll_get_reg0x3c_value(void)
1848 {
1849 return REG_READ(JPEG_DEC_REG0X3C_ADDR);
1850 }
1851
jpeg_dec_ll_set_reg0x3c_value(uint32_t value)1852 static inline void jpeg_dec_ll_set_reg0x3c_value(uint32_t value)
1853 {
1854 REG_WRITE(JPEG_DEC_REG0X3C_ADDR,value);
1855 }
1856
1857 /* REG_0x3c:reg0x3c->hufac_len_yc:0x3c,y huffman table acc,0x0,R/W*/
jpeg_dec_ll_get_reg0x3c_hufac_len_yc(void)1858 static inline uint32_t jpeg_dec_ll_get_reg0x3c_hufac_len_yc(void)
1859 {
1860 return REG_READ(JPEG_DEC_REG0X3C_ADDR);
1861 }
1862
jpeg_dec_ll_set_reg0x3c_hufac_len_yc(uint32_t value)1863 static inline void jpeg_dec_ll_set_reg0x3c_hufac_len_yc(uint32_t value)
1864 {
1865 REG_WRITE(JPEG_DEC_REG0X3C_ADDR,value);
1866 }
1867
1868 /* REG_0x3D */
1869 #define JPEG_DEC_REG0X3D_ADDR (JPEG_DEC_LL_REG_BASE + 0x3D*4) //REG ADDR :0x480400f4
1870 #define JPEG_DEC_REG0X3D_HUFAC_LEN_YD_POS (0)
1871 #define JPEG_DEC_REG0X3D_HUFAC_LEN_YD_MASK (0xFFFFFFFF)
1872
jpeg_dec_ll_get_reg0x3d_value(void)1873 static inline uint32_t jpeg_dec_ll_get_reg0x3d_value(void)
1874 {
1875 return REG_READ(JPEG_DEC_REG0X3D_ADDR);
1876 }
1877
jpeg_dec_ll_set_reg0x3d_value(uint32_t value)1878 static inline void jpeg_dec_ll_set_reg0x3d_value(uint32_t value)
1879 {
1880 REG_WRITE(JPEG_DEC_REG0X3D_ADDR,value);
1881 }
1882
1883 /* REG_0x3d:reg0x3d->hufac_len_yd:0x3d,y huffman table acd,0x0,R/W*/
jpeg_dec_ll_get_reg0x3d_hufac_len_yd(void)1884 static inline uint32_t jpeg_dec_ll_get_reg0x3d_hufac_len_yd(void)
1885 {
1886 return REG_READ(JPEG_DEC_REG0X3D_ADDR);
1887 }
1888
jpeg_dec_ll_set_reg0x3d_hufac_len_yd(uint32_t value)1889 static inline void jpeg_dec_ll_set_reg0x3d_hufac_len_yd(uint32_t value)
1890 {
1891 REG_WRITE(JPEG_DEC_REG0X3D_ADDR,value);
1892 }
1893
1894 /* REG_0x3E */
1895 #define JPEG_DEC_REG0X3E_ADDR (JPEG_DEC_LL_REG_BASE + 0x3E*4) //REG ADDR :0x480400f8
1896 #define JPEG_DEC_REG0X3E_HUFAC_LEN_YE_POS (0)
1897 #define JPEG_DEC_REG0X3E_HUFAC_LEN_YE_MASK (0xFFFFFFFF)
1898
jpeg_dec_ll_get_reg0x3e_value(void)1899 static inline uint32_t jpeg_dec_ll_get_reg0x3e_value(void)
1900 {
1901 return REG_READ(JPEG_DEC_REG0X3E_ADDR);
1902 }
1903
jpeg_dec_ll_set_reg0x3e_value(uint32_t value)1904 static inline void jpeg_dec_ll_set_reg0x3e_value(uint32_t value)
1905 {
1906 REG_WRITE(JPEG_DEC_REG0X3E_ADDR,value);
1907 }
1908
1909 /* REG_0x3e:reg0x3e->hufac_len_ye:0x3e,y huffman table ace,0x0,R/W*/
jpeg_dec_ll_get_reg0x3e_hufac_len_ye(void)1910 static inline uint32_t jpeg_dec_ll_get_reg0x3e_hufac_len_ye(void)
1911 {
1912 return REG_READ(JPEG_DEC_REG0X3E_ADDR);
1913 }
1914
jpeg_dec_ll_set_reg0x3e_hufac_len_ye(uint32_t value)1915 static inline void jpeg_dec_ll_set_reg0x3e_hufac_len_ye(uint32_t value)
1916 {
1917 REG_WRITE(JPEG_DEC_REG0X3E_ADDR,value);
1918 }
1919
1920 /* REG_0x3F */
1921 #define JPEG_DEC_REG0X3F_ADDR (JPEG_DEC_LL_REG_BASE + 0x3F*4) //REG ADDR :0x480400fc
1922 #define JPEG_DEC_REG0X3F_HUFAC_LEN_YF_POS (0)
1923 #define JPEG_DEC_REG0X3F_HUFAC_LEN_YF_MASK (0xFFFFFFFF)
1924
jpeg_dec_ll_get_reg0x3f_value(void)1925 static inline uint32_t jpeg_dec_ll_get_reg0x3f_value(void)
1926 {
1927 return REG_READ(JPEG_DEC_REG0X3F_ADDR);
1928 }
1929
jpeg_dec_ll_set_reg0x3f_value(uint32_t value)1930 static inline void jpeg_dec_ll_set_reg0x3f_value(uint32_t value)
1931 {
1932 REG_WRITE(JPEG_DEC_REG0X3F_ADDR,value);
1933 }
1934
1935 /* REG_0x3f:reg0x3f->hufac_len_yf:0x3f,y huffman table acf,0x0,R/W*/
jpeg_dec_ll_get_reg0x3f_hufac_len_yf(void)1936 static inline uint32_t jpeg_dec_ll_get_reg0x3f_hufac_len_yf(void)
1937 {
1938 return REG_READ(JPEG_DEC_REG0X3F_ADDR);
1939 }
1940
jpeg_dec_ll_set_reg0x3f_hufac_len_yf(uint32_t value)1941 static inline void jpeg_dec_ll_set_reg0x3f_hufac_len_yf(uint32_t value)
1942 {
1943 REG_WRITE(JPEG_DEC_REG0X3F_ADDR,value);
1944 }
1945
1946 /* REG_0x40 */
1947 #define JPEG_DEC_REG0X40_ADDR (JPEG_DEC_LL_REG_BASE + 0x40*4) //REG ADDR :0x48040100
1948 #define JPEG_DEC_REG0X40_HUFAC_LEN_UV0_POS (0)
1949 #define JPEG_DEC_REG0X40_HUFAC_LEN_UV0_MASK (0xFFFFFFFF)
1950
jpeg_dec_ll_get_reg0x40_value(void)1951 static inline uint32_t jpeg_dec_ll_get_reg0x40_value(void)
1952 {
1953 return REG_READ(JPEG_DEC_REG0X40_ADDR);
1954 }
1955
jpeg_dec_ll_set_reg0x40_value(uint32_t value)1956 static inline void jpeg_dec_ll_set_reg0x40_value(uint32_t value)
1957 {
1958 REG_WRITE(JPEG_DEC_REG0X40_ADDR,value);
1959 }
1960
1961 /* REG_0x40:reg0x40->hufac_len_uv0:0x40,uv huffman table ac0,0x0,R/W*/
jpeg_dec_ll_get_reg0x40_hufac_len_uv0(void)1962 static inline uint32_t jpeg_dec_ll_get_reg0x40_hufac_len_uv0(void)
1963 {
1964 return REG_READ(JPEG_DEC_REG0X40_ADDR);
1965 }
1966
jpeg_dec_ll_set_reg0x40_hufac_len_uv0(uint32_t value)1967 static inline void jpeg_dec_ll_set_reg0x40_hufac_len_uv0(uint32_t value)
1968 {
1969 REG_WRITE(JPEG_DEC_REG0X40_ADDR,value);
1970 }
1971
1972 /* REG_0x41 */
1973 #define JPEG_DEC_REG0X41_ADDR (JPEG_DEC_LL_REG_BASE + 0x41*4) //REG ADDR :0x48040104
1974 #define JPEG_DEC_REG0X41_HUFAC_LEN_UV1_POS (0)
1975 #define JPEG_DEC_REG0X41_HUFAC_LEN_UV1_MASK (0xFFFFFFFF)
1976
jpeg_dec_ll_get_reg0x41_value(void)1977 static inline uint32_t jpeg_dec_ll_get_reg0x41_value(void)
1978 {
1979 return REG_READ(JPEG_DEC_REG0X41_ADDR);
1980 }
1981
jpeg_dec_ll_set_reg0x41_value(uint32_t value)1982 static inline void jpeg_dec_ll_set_reg0x41_value(uint32_t value)
1983 {
1984 REG_WRITE(JPEG_DEC_REG0X41_ADDR,value);
1985 }
1986
1987 /* REG_0x41:reg0x41->hufac_len_uv1:0x41,uv huffman table ac1,0x0,R/W*/
jpeg_dec_ll_get_reg0x41_hufac_len_uv1(void)1988 static inline uint32_t jpeg_dec_ll_get_reg0x41_hufac_len_uv1(void)
1989 {
1990 return REG_READ(JPEG_DEC_REG0X41_ADDR);
1991 }
1992
jpeg_dec_ll_set_reg0x41_hufac_len_uv1(uint32_t value)1993 static inline void jpeg_dec_ll_set_reg0x41_hufac_len_uv1(uint32_t value)
1994 {
1995 REG_WRITE(JPEG_DEC_REG0X41_ADDR,value);
1996 }
1997
1998 /* REG_0x42 */
1999 #define JPEG_DEC_REG0X42_ADDR (JPEG_DEC_LL_REG_BASE + 0x42*4) //REG ADDR :0x48040108
2000 #define JPEG_DEC_REG0X42_HUFAC_LEN_UV2_POS (0)
2001 #define JPEG_DEC_REG0X42_HUFAC_LEN_UV2_MASK (0xFFFFFFFF)
2002
jpeg_dec_ll_get_reg0x42_value(void)2003 static inline uint32_t jpeg_dec_ll_get_reg0x42_value(void)
2004 {
2005 return REG_READ(JPEG_DEC_REG0X42_ADDR);
2006 }
2007
jpeg_dec_ll_set_reg0x42_value(uint32_t value)2008 static inline void jpeg_dec_ll_set_reg0x42_value(uint32_t value)
2009 {
2010 REG_WRITE(JPEG_DEC_REG0X42_ADDR,value);
2011 }
2012
2013 /* REG_0x42:reg0x42->hufac_len_uv2:0x42,uv huffman table ac2,0x0,R/W*/
jpeg_dec_ll_get_reg0x42_hufac_len_uv2(void)2014 static inline uint32_t jpeg_dec_ll_get_reg0x42_hufac_len_uv2(void)
2015 {
2016 return REG_READ(JPEG_DEC_REG0X42_ADDR);
2017 }
2018
jpeg_dec_ll_set_reg0x42_hufac_len_uv2(uint32_t value)2019 static inline void jpeg_dec_ll_set_reg0x42_hufac_len_uv2(uint32_t value)
2020 {
2021 REG_WRITE(JPEG_DEC_REG0X42_ADDR,value);
2022 }
2023
2024 /* REG_0x43 */
2025 #define JPEG_DEC_REG0X43_ADDR (JPEG_DEC_LL_REG_BASE + 0x43*4) //REG ADDR :0x4804010c
2026 #define JPEG_DEC_REG0X43_HUFAC_LEN_UV3_POS (0)
2027 #define JPEG_DEC_REG0X43_HUFAC_LEN_UV3_MASK (0xFFFFFFFF)
2028
jpeg_dec_ll_get_reg0x43_value(void)2029 static inline uint32_t jpeg_dec_ll_get_reg0x43_value(void)
2030 {
2031 return REG_READ(JPEG_DEC_REG0X43_ADDR);
2032 }
2033
jpeg_dec_ll_set_reg0x43_value(uint32_t value)2034 static inline void jpeg_dec_ll_set_reg0x43_value(uint32_t value)
2035 {
2036 REG_WRITE(JPEG_DEC_REG0X43_ADDR,value);
2037 }
2038
2039 /* REG_0x43:reg0x43->hufac_len_uv3:0x43,uv huffman table ac3,0x0,R/W*/
jpeg_dec_ll_get_reg0x43_hufac_len_uv3(void)2040 static inline uint32_t jpeg_dec_ll_get_reg0x43_hufac_len_uv3(void)
2041 {
2042 return REG_READ(JPEG_DEC_REG0X43_ADDR);
2043 }
2044
jpeg_dec_ll_set_reg0x43_hufac_len_uv3(uint32_t value)2045 static inline void jpeg_dec_ll_set_reg0x43_hufac_len_uv3(uint32_t value)
2046 {
2047 REG_WRITE(JPEG_DEC_REG0X43_ADDR,value);
2048 }
2049
2050 /* REG_0x44 */
2051 #define JPEG_DEC_REG0X44_ADDR (JPEG_DEC_LL_REG_BASE + 0x44*4) //REG ADDR :0x48040110
2052 #define JPEG_DEC_REG0X44_HUFAC_LEN_UV4_POS (0)
2053 #define JPEG_DEC_REG0X44_HUFAC_LEN_UV4_MASK (0xFFFFFFFF)
2054
jpeg_dec_ll_get_reg0x44_value(void)2055 static inline uint32_t jpeg_dec_ll_get_reg0x44_value(void)
2056 {
2057 return REG_READ(JPEG_DEC_REG0X44_ADDR);
2058 }
2059
jpeg_dec_ll_set_reg0x44_value(uint32_t value)2060 static inline void jpeg_dec_ll_set_reg0x44_value(uint32_t value)
2061 {
2062 REG_WRITE(JPEG_DEC_REG0X44_ADDR,value);
2063 }
2064
2065 /* REG_0x44:reg0x44->hufac_len_uv4:0x44,uv huffman table ac4,0x0,R/W*/
jpeg_dec_ll_get_reg0x44_hufac_len_uv4(void)2066 static inline uint32_t jpeg_dec_ll_get_reg0x44_hufac_len_uv4(void)
2067 {
2068 return REG_READ(JPEG_DEC_REG0X44_ADDR);
2069 }
2070
jpeg_dec_ll_set_reg0x44_hufac_len_uv4(uint32_t value)2071 static inline void jpeg_dec_ll_set_reg0x44_hufac_len_uv4(uint32_t value)
2072 {
2073 REG_WRITE(JPEG_DEC_REG0X44_ADDR,value);
2074 }
2075
2076 /* REG_0x45 */
2077 #define JPEG_DEC_REG0X45_ADDR (JPEG_DEC_LL_REG_BASE + 0x45*4) //REG ADDR :0x48040114
2078 #define JPEG_DEC_REG0X45_HUFAC_LEN_UV5_POS (0)
2079 #define JPEG_DEC_REG0X45_HUFAC_LEN_UV5_MASK (0xFFFFFFFF)
2080
jpeg_dec_ll_get_reg0x45_value(void)2081 static inline uint32_t jpeg_dec_ll_get_reg0x45_value(void)
2082 {
2083 return REG_READ(JPEG_DEC_REG0X45_ADDR);
2084 }
2085
jpeg_dec_ll_set_reg0x45_value(uint32_t value)2086 static inline void jpeg_dec_ll_set_reg0x45_value(uint32_t value)
2087 {
2088 REG_WRITE(JPEG_DEC_REG0X45_ADDR,value);
2089 }
2090
2091 /* REG_0x45:reg0x45->hufac_len_uv5:0x45,uv huffman table ac5,0x0,R/W*/
jpeg_dec_ll_get_reg0x45_hufac_len_uv5(void)2092 static inline uint32_t jpeg_dec_ll_get_reg0x45_hufac_len_uv5(void)
2093 {
2094 return REG_READ(JPEG_DEC_REG0X45_ADDR);
2095 }
2096
jpeg_dec_ll_set_reg0x45_hufac_len_uv5(uint32_t value)2097 static inline void jpeg_dec_ll_set_reg0x45_hufac_len_uv5(uint32_t value)
2098 {
2099 REG_WRITE(JPEG_DEC_REG0X45_ADDR,value);
2100 }
2101
2102 /* REG_0x46 */
2103 #define JPEG_DEC_REG0X46_ADDR (JPEG_DEC_LL_REG_BASE + 0x46*4) //REG ADDR :0x48040118
2104 #define JPEG_DEC_REG0X46_HUFAC_LEN_UV6_POS (0)
2105 #define JPEG_DEC_REG0X46_HUFAC_LEN_UV6_MASK (0xFFFFFFFF)
2106
jpeg_dec_ll_get_reg0x46_value(void)2107 static inline uint32_t jpeg_dec_ll_get_reg0x46_value(void)
2108 {
2109 return REG_READ(JPEG_DEC_REG0X46_ADDR);
2110 }
2111
jpeg_dec_ll_set_reg0x46_value(uint32_t value)2112 static inline void jpeg_dec_ll_set_reg0x46_value(uint32_t value)
2113 {
2114 REG_WRITE(JPEG_DEC_REG0X46_ADDR,value);
2115 }
2116
2117 /* REG_0x46:reg0x46->hufac_len_uv6:0x46,uv huffman table ac6,0x0,R/W*/
jpeg_dec_ll_get_reg0x46_hufac_len_uv6(void)2118 static inline uint32_t jpeg_dec_ll_get_reg0x46_hufac_len_uv6(void)
2119 {
2120 return REG_READ(JPEG_DEC_REG0X46_ADDR);
2121 }
2122
jpeg_dec_ll_set_reg0x46_hufac_len_uv6(uint32_t value)2123 static inline void jpeg_dec_ll_set_reg0x46_hufac_len_uv6(uint32_t value)
2124 {
2125 REG_WRITE(JPEG_DEC_REG0X46_ADDR,value);
2126 }
2127
2128 /* REG_0x47 */
2129 #define JPEG_DEC_REG0X47_ADDR (JPEG_DEC_LL_REG_BASE + 0x47*4) //REG ADDR :0x4804011c
2130 #define JPEG_DEC_REG0X47_HUFAC_LEN_UV7_POS (0)
2131 #define JPEG_DEC_REG0X47_HUFAC_LEN_UV7_MASK (0xFFFFFFFF)
2132
jpeg_dec_ll_get_reg0x47_value(void)2133 static inline uint32_t jpeg_dec_ll_get_reg0x47_value(void)
2134 {
2135 return REG_READ(JPEG_DEC_REG0X47_ADDR);
2136 }
2137
jpeg_dec_ll_set_reg0x47_value(uint32_t value)2138 static inline void jpeg_dec_ll_set_reg0x47_value(uint32_t value)
2139 {
2140 REG_WRITE(JPEG_DEC_REG0X47_ADDR,value);
2141 }
2142
2143 /* REG_0x47:reg0x47->hufac_len_uv7:0x47,uv huffman table ac7,0x0,R/W*/
jpeg_dec_ll_get_reg0x47_hufac_len_uv7(void)2144 static inline uint32_t jpeg_dec_ll_get_reg0x47_hufac_len_uv7(void)
2145 {
2146 return REG_READ(JPEG_DEC_REG0X47_ADDR);
2147 }
2148
jpeg_dec_ll_set_reg0x47_hufac_len_uv7(uint32_t value)2149 static inline void jpeg_dec_ll_set_reg0x47_hufac_len_uv7(uint32_t value)
2150 {
2151 REG_WRITE(JPEG_DEC_REG0X47_ADDR,value);
2152 }
2153
2154 /* REG_0x48 */
2155 #define JPEG_DEC_REG0X48_ADDR (JPEG_DEC_LL_REG_BASE + 0x48*4) //REG ADDR :0x48040120
2156 #define JPEG_DEC_REG0X48_HUFAC_LEN_UV8_POS (0)
2157 #define JPEG_DEC_REG0X48_HUFAC_LEN_UV8_MASK (0xFFFFFFFF)
2158
jpeg_dec_ll_get_reg0x48_value(void)2159 static inline uint32_t jpeg_dec_ll_get_reg0x48_value(void)
2160 {
2161 return REG_READ(JPEG_DEC_REG0X48_ADDR);
2162 }
2163
jpeg_dec_ll_set_reg0x48_value(uint32_t value)2164 static inline void jpeg_dec_ll_set_reg0x48_value(uint32_t value)
2165 {
2166 REG_WRITE(JPEG_DEC_REG0X48_ADDR,value);
2167 }
2168
2169 /* REG_0x48:reg0x48->hufac_len_uv8:0x48,uv huffman table ac8,0x0,R/W*/
jpeg_dec_ll_get_reg0x48_hufac_len_uv8(void)2170 static inline uint32_t jpeg_dec_ll_get_reg0x48_hufac_len_uv8(void)
2171 {
2172 return REG_READ(JPEG_DEC_REG0X48_ADDR);
2173 }
2174
jpeg_dec_ll_set_reg0x48_hufac_len_uv8(uint32_t value)2175 static inline void jpeg_dec_ll_set_reg0x48_hufac_len_uv8(uint32_t value)
2176 {
2177 REG_WRITE(JPEG_DEC_REG0X48_ADDR,value);
2178 }
2179
2180 /* REG_0x49 */
2181 #define JPEG_DEC_REG0X49_ADDR (JPEG_DEC_LL_REG_BASE + 0x49*4) //REG ADDR :0x48040124
2182 #define JPEG_DEC_REG0X49_HUFAC_LEN_UV9_POS (0)
2183 #define JPEG_DEC_REG0X49_HUFAC_LEN_UV9_MASK (0xFFFFFFFF)
2184
jpeg_dec_ll_get_reg0x49_value(void)2185 static inline uint32_t jpeg_dec_ll_get_reg0x49_value(void)
2186 {
2187 return REG_READ(JPEG_DEC_REG0X49_ADDR);
2188 }
2189
jpeg_dec_ll_set_reg0x49_value(uint32_t value)2190 static inline void jpeg_dec_ll_set_reg0x49_value(uint32_t value)
2191 {
2192 REG_WRITE(JPEG_DEC_REG0X49_ADDR,value);
2193 }
2194
2195 /* REG_0x49:reg0x49->hufac_len_uv9:0x49,uv huffman table ac9,0x0,R/W*/
jpeg_dec_ll_get_reg0x49_hufac_len_uv9(void)2196 static inline uint32_t jpeg_dec_ll_get_reg0x49_hufac_len_uv9(void)
2197 {
2198 return REG_READ(JPEG_DEC_REG0X49_ADDR);
2199 }
2200
jpeg_dec_ll_set_reg0x49_hufac_len_uv9(uint32_t value)2201 static inline void jpeg_dec_ll_set_reg0x49_hufac_len_uv9(uint32_t value)
2202 {
2203 REG_WRITE(JPEG_DEC_REG0X49_ADDR,value);
2204 }
2205
2206 /* REG_0x4A */
2207 #define JPEG_DEC_REG0X4A_ADDR (JPEG_DEC_LL_REG_BASE + 0x4A*4) //REG ADDR :0x48040128
2208 #define JPEG_DEC_REG0X4A_HUFAC_LEN_UVA_POS (0)
2209 #define JPEG_DEC_REG0X4A_HUFAC_LEN_UVA_MASK (0xFFFFFFFF)
2210
jpeg_dec_ll_get_reg0x4a_value(void)2211 static inline uint32_t jpeg_dec_ll_get_reg0x4a_value(void)
2212 {
2213 return REG_READ(JPEG_DEC_REG0X4A_ADDR);
2214 }
2215
jpeg_dec_ll_set_reg0x4a_value(uint32_t value)2216 static inline void jpeg_dec_ll_set_reg0x4a_value(uint32_t value)
2217 {
2218 REG_WRITE(JPEG_DEC_REG0X4A_ADDR,value);
2219 }
2220
2221 /* REG_0x4a:reg0x4a->hufac_len_uva:0x4a,uv huffman table aca,0x0,R/W*/
jpeg_dec_ll_get_reg0x4a_hufac_len_uva(void)2222 static inline uint32_t jpeg_dec_ll_get_reg0x4a_hufac_len_uva(void)
2223 {
2224 return REG_READ(JPEG_DEC_REG0X4A_ADDR);
2225 }
2226
jpeg_dec_ll_set_reg0x4a_hufac_len_uva(uint32_t value)2227 static inline void jpeg_dec_ll_set_reg0x4a_hufac_len_uva(uint32_t value)
2228 {
2229 REG_WRITE(JPEG_DEC_REG0X4A_ADDR,value);
2230 }
2231
2232 /* REG_0x4B */
2233 #define JPEG_DEC_REG0X4B_ADDR (JPEG_DEC_LL_REG_BASE + 0x4B*4) //REG ADDR :0x4804012c
2234 #define JPEG_DEC_REG0X4B_HUFAC_LEN_UVB_POS (0)
2235 #define JPEG_DEC_REG0X4B_HUFAC_LEN_UVB_MASK (0xFFFFFFFF)
2236
jpeg_dec_ll_get_reg0x4b_value(void)2237 static inline uint32_t jpeg_dec_ll_get_reg0x4b_value(void)
2238 {
2239 return REG_READ(JPEG_DEC_REG0X4B_ADDR);
2240 }
2241
jpeg_dec_ll_set_reg0x4b_value(uint32_t value)2242 static inline void jpeg_dec_ll_set_reg0x4b_value(uint32_t value)
2243 {
2244 REG_WRITE(JPEG_DEC_REG0X4B_ADDR,value);
2245 }
2246
2247 /* REG_0x4b:reg0x4b->hufac_len_uvb:0x4b,uv huffman table acb,0x0,R/W*/
jpeg_dec_ll_get_reg0x4b_hufac_len_uvb(void)2248 static inline uint32_t jpeg_dec_ll_get_reg0x4b_hufac_len_uvb(void)
2249 {
2250 return REG_READ(JPEG_DEC_REG0X4B_ADDR);
2251 }
2252
jpeg_dec_ll_set_reg0x4b_hufac_len_uvb(uint32_t value)2253 static inline void jpeg_dec_ll_set_reg0x4b_hufac_len_uvb(uint32_t value)
2254 {
2255 REG_WRITE(JPEG_DEC_REG0X4B_ADDR,value);
2256 }
2257
2258 /* REG_0x4C */
2259 #define JPEG_DEC_REG0X4C_ADDR (JPEG_DEC_LL_REG_BASE + 0x4C*4) //REG ADDR :0x48040130
2260 #define JPEG_DEC_REG0X4C_HUFAC_LEN_UVC_POS (0)
2261 #define JPEG_DEC_REG0X4C_HUFAC_LEN_UVC_MASK (0xFFFFFFFF)
2262
jpeg_dec_ll_get_reg0x4c_value(void)2263 static inline uint32_t jpeg_dec_ll_get_reg0x4c_value(void)
2264 {
2265 return REG_READ(JPEG_DEC_REG0X4C_ADDR);
2266 }
2267
jpeg_dec_ll_set_reg0x4c_value(uint32_t value)2268 static inline void jpeg_dec_ll_set_reg0x4c_value(uint32_t value)
2269 {
2270 REG_WRITE(JPEG_DEC_REG0X4C_ADDR,value);
2271 }
2272
2273 /* REG_0x4c:reg0x4c->hufac_len_uvc:0x4c,uv huffman table acc,0x0,R/W*/
jpeg_dec_ll_get_reg0x4c_hufac_len_uvc(void)2274 static inline uint32_t jpeg_dec_ll_get_reg0x4c_hufac_len_uvc(void)
2275 {
2276 return REG_READ(JPEG_DEC_REG0X4C_ADDR);
2277 }
2278
jpeg_dec_ll_set_reg0x4c_hufac_len_uvc(uint32_t value)2279 static inline void jpeg_dec_ll_set_reg0x4c_hufac_len_uvc(uint32_t value)
2280 {
2281 REG_WRITE(JPEG_DEC_REG0X4C_ADDR,value);
2282 }
2283
2284 /* REG_0x4D */
2285 #define JPEG_DEC_REG0X4D_ADDR (JPEG_DEC_LL_REG_BASE + 0x4D*4) //REG ADDR :0x48040134
2286 #define JPEG_DEC_REG0X4D_HUFAC_LEN_UVD_POS (0)
2287 #define JPEG_DEC_REG0X4D_HUFAC_LEN_UVD_MASK (0xFFFFFFFF)
2288
jpeg_dec_ll_get_reg0x4d_value(void)2289 static inline uint32_t jpeg_dec_ll_get_reg0x4d_value(void)
2290 {
2291 return REG_READ(JPEG_DEC_REG0X4D_ADDR);
2292 }
2293
jpeg_dec_ll_set_reg0x4d_value(uint32_t value)2294 static inline void jpeg_dec_ll_set_reg0x4d_value(uint32_t value)
2295 {
2296 REG_WRITE(JPEG_DEC_REG0X4D_ADDR,value);
2297 }
2298
2299 /* REG_0x4d:reg0x4d->hufac_len_uvd:0x4d,uv huffman table acd,0x0,R/W*/
jpeg_dec_ll_get_reg0x4d_hufac_len_uvd(void)2300 static inline uint32_t jpeg_dec_ll_get_reg0x4d_hufac_len_uvd(void)
2301 {
2302 return REG_READ(JPEG_DEC_REG0X4D_ADDR);
2303 }
2304
jpeg_dec_ll_set_reg0x4d_hufac_len_uvd(uint32_t value)2305 static inline void jpeg_dec_ll_set_reg0x4d_hufac_len_uvd(uint32_t value)
2306 {
2307 REG_WRITE(JPEG_DEC_REG0X4D_ADDR,value);
2308 }
2309
2310 /* REG_0x4E */
2311 #define JPEG_DEC_REG0X4E_ADDR (JPEG_DEC_LL_REG_BASE + 0x4E*4) //REG ADDR :0x48040138
2312 #define JPEG_DEC_REG0X4E_HUFAC_LEN_UVE_POS (0)
2313 #define JPEG_DEC_REG0X4E_HUFAC_LEN_UVE_MASK (0xFFFFFFFF)
2314
jpeg_dec_ll_get_reg0x4e_value(void)2315 static inline uint32_t jpeg_dec_ll_get_reg0x4e_value(void)
2316 {
2317 return REG_READ(JPEG_DEC_REG0X4E_ADDR);
2318 }
2319
jpeg_dec_ll_set_reg0x4e_value(uint32_t value)2320 static inline void jpeg_dec_ll_set_reg0x4e_value(uint32_t value)
2321 {
2322 REG_WRITE(JPEG_DEC_REG0X4E_ADDR,value);
2323 }
2324
2325 /* REG_0x4e:reg0x4e->hufac_len_uve:0x4e,uv huffman table ace,0x0,R/W*/
jpeg_dec_ll_get_reg0x4e_hufac_len_uve(void)2326 static inline uint32_t jpeg_dec_ll_get_reg0x4e_hufac_len_uve(void)
2327 {
2328 return REG_READ(JPEG_DEC_REG0X4E_ADDR);
2329 }
2330
jpeg_dec_ll_set_reg0x4e_hufac_len_uve(uint32_t value)2331 static inline void jpeg_dec_ll_set_reg0x4e_hufac_len_uve(uint32_t value)
2332 {
2333 REG_WRITE(JPEG_DEC_REG0X4E_ADDR,value);
2334 }
2335
2336 /* REG_0x4F */
2337 #define JPEG_DEC_REG0X4F_ADDR (JPEG_DEC_LL_REG_BASE + 0x4F*4) //REG ADDR :0x4804013c
2338 #define JPEG_DEC_REG0X4F_HUFAC_LEN_UVF_POS (0)
2339 #define JPEG_DEC_REG0X4F_HUFAC_LEN_UVF_MASK (0xFFFFFFFF)
2340
jpeg_dec_ll_get_reg0x4f_value(void)2341 static inline uint32_t jpeg_dec_ll_get_reg0x4f_value(void)
2342 {
2343 return REG_READ(JPEG_DEC_REG0X4F_ADDR);
2344 }
2345
jpeg_dec_ll_set_reg0x4f_value(uint32_t value)2346 static inline void jpeg_dec_ll_set_reg0x4f_value(uint32_t value)
2347 {
2348 REG_WRITE(JPEG_DEC_REG0X4F_ADDR,value);
2349 }
2350
2351 /* REG_0x4f:reg0x4f->hufac_len_uvf:0x4f,uv huffman table acf,0x0,R/W*/
jpeg_dec_ll_get_reg0x4f_hufac_len_uvf(void)2352 static inline uint32_t jpeg_dec_ll_get_reg0x4f_hufac_len_uvf(void)
2353 {
2354 return REG_READ(JPEG_DEC_REG0X4F_ADDR);
2355 }
2356
jpeg_dec_ll_set_reg0x4f_hufac_len_uvf(uint32_t value)2357 static inline void jpeg_dec_ll_set_reg0x4f_hufac_len_uvf(uint32_t value)
2358 {
2359 REG_WRITE(JPEG_DEC_REG0X4F_ADDR,value);
2360 }
2361
2362 /* REG_0x57 */
2363 #define JPEG_DEC_REG0X57_ADDR (JPEG_DEC_LL_REG_BASE + 0x57*4) //REG ADDR :0x4804015c
2364 #define JPEG_DEC_REG0X57_MASTER_WR_CNT_POS (0)
2365 #define JPEG_DEC_REG0X57_MASTER_WR_CNT_MASK (0xFFFFFFFF)
2366
jpeg_dec_ll_get_reg0x57_value(void)2367 static inline uint32_t jpeg_dec_ll_get_reg0x57_value(void)
2368 {
2369 return REG_READ(JPEG_DEC_REG0X57_ADDR);
2370 }
2371
2372 /* REG_0x57:reg0x57->master_wr_cnt:0x57,master write count,None,R*/
jpeg_dec_ll_get_reg0x57_master_wr_cnt(void)2373 static inline uint32_t jpeg_dec_ll_get_reg0x57_master_wr_cnt(void)
2374 {
2375 return REG_READ(JPEG_DEC_REG0X57_ADDR);
2376 }
2377
2378 /* REG_0x58 */
2379 #define JPEG_DEC_REG0X58_ADDR (JPEG_DEC_LL_REG_BASE + 0x58*4) //REG ADDR :0x48040160
2380 #define JPEG_DEC_REG0X58_BASE_RADDR_POS (0)
2381 #define JPEG_DEC_REG0X58_BASE_RADDR_MASK (0xFFFFFFFF)
2382
jpeg_dec_ll_get_reg0x58_value(void)2383 static inline uint32_t jpeg_dec_ll_get_reg0x58_value(void)
2384 {
2385 return REG_READ(JPEG_DEC_REG0X58_ADDR);
2386 }
2387
jpeg_dec_ll_set_reg0x58_value(uint32_t value)2388 static inline void jpeg_dec_ll_set_reg0x58_value(uint32_t value)
2389 {
2390 REG_WRITE(JPEG_DEC_REG0X58_ADDR,value);
2391 }
2392
2393 /* REG_0x58:reg0x58->BASE_RADDR:0x58,ahb memory read baseaddr,0x0,R/W*/
jpeg_dec_ll_get_reg0x58_base_raddr(void)2394 static inline uint32_t jpeg_dec_ll_get_reg0x58_base_raddr(void)
2395 {
2396 return REG_READ(JPEG_DEC_REG0X58_ADDR);
2397 }
2398
jpeg_dec_ll_set_reg0x58_base_raddr(uint32_t value)2399 static inline void jpeg_dec_ll_set_reg0x58_base_raddr(uint32_t value)
2400 {
2401 REG_WRITE(JPEG_DEC_REG0X58_ADDR,value);
2402 }
2403
2404 /* REG_0x59 */
2405 #define JPEG_DEC_REG0X59_ADDR (JPEG_DEC_LL_REG_BASE + 0x59*4) //REG ADDR :0x48040164
2406 #define JPEG_DEC_REG0X59_BASE_WADDR_POS (0)
2407 #define JPEG_DEC_REG0X59_BASE_WADDR_MASK (0xFFFFFFFF)
2408
jpeg_dec_ll_get_reg0x59_value(void)2409 static inline uint32_t jpeg_dec_ll_get_reg0x59_value(void)
2410 {
2411 return REG_READ(JPEG_DEC_REG0X59_ADDR);
2412 }
2413
jpeg_dec_ll_set_reg0x59_value(uint32_t value)2414 static inline void jpeg_dec_ll_set_reg0x59_value(uint32_t value)
2415 {
2416 REG_WRITE(JPEG_DEC_REG0X59_ADDR,value);
2417 }
2418
2419 /* REG_0x59:reg0x59->BASE_WADDR:0x59,ahb memory write baseaddr,0x0,R/W*/
jpeg_dec_ll_get_reg0x59_base_waddr(void)2420 static inline uint32_t jpeg_dec_ll_get_reg0x59_base_waddr(void)
2421 {
2422 return REG_READ(JPEG_DEC_REG0X59_ADDR);
2423 }
2424
jpeg_dec_ll_set_reg0x59_base_waddr(uint32_t value)2425 static inline void jpeg_dec_ll_set_reg0x59_base_waddr(uint32_t value)
2426 {
2427 REG_WRITE(JPEG_DEC_REG0X59_ADDR,value);
2428 }
2429
2430 /* REG_0x5A */
2431 #define JPEG_DEC_REG0X5A_ADDR (JPEG_DEC_LL_REG_BASE + 0x5A*4) //REG ADDR :0x48040168
2432 #define JPEG_DEC_REG0X5A_BASE_RD_LEN_POS (0)
2433 #define JPEG_DEC_REG0X5A_BASE_RD_LEN_MASK (0xFFFFFFFF)
2434
jpeg_dec_ll_get_reg0x5a_value(void)2435 static inline uint32_t jpeg_dec_ll_get_reg0x5a_value(void)
2436 {
2437 return REG_READ(JPEG_DEC_REG0X5A_ADDR);
2438 }
2439
jpeg_dec_ll_set_reg0x5a_value(uint32_t value)2440 static inline void jpeg_dec_ll_set_reg0x5a_value(uint32_t value)
2441 {
2442 REG_WRITE(JPEG_DEC_REG0X5A_ADDR,value);
2443 }
2444
2445 /* REG_0x5a:reg0x5a->BASE_RD_LEN:0x5a,ahb memory read len,0x0,R/W*/
jpeg_dec_ll_get_reg0x5a_base_rd_len(void)2446 static inline uint32_t jpeg_dec_ll_get_reg0x5a_base_rd_len(void)
2447 {
2448 return REG_READ(JPEG_DEC_REG0X5A_ADDR);
2449 }
2450
jpeg_dec_ll_set_reg0x5a_base_rd_len(uint32_t value)2451 static inline void jpeg_dec_ll_set_reg0x5a_base_rd_len(uint32_t value)
2452 {
2453 REG_WRITE(JPEG_DEC_REG0X5A_ADDR,value);
2454 }
2455
2456 /* REG_0x5B */
2457 #define JPEG_DEC_REG0X5B_ADDR (JPEG_DEC_LL_REG_BASE + 0x5B*4) //REG ADDR :0x4804016c
2458 #define JPEG_DEC_REG0X5B_BASE_WR_LEN_POS (0)
2459 #define JPEG_DEC_REG0X5B_BASE_WR_LEN_MASK (0xFFFFFFFF)
2460
jpeg_dec_ll_get_reg0x5b_value(void)2461 static inline uint32_t jpeg_dec_ll_get_reg0x5b_value(void)
2462 {
2463 return REG_READ(JPEG_DEC_REG0X5B_ADDR);
2464 }
2465
jpeg_dec_ll_set_reg0x5b_value(uint32_t value)2466 static inline void jpeg_dec_ll_set_reg0x5b_value(uint32_t value)
2467 {
2468 REG_WRITE(JPEG_DEC_REG0X5B_ADDR,value);
2469 }
2470
2471 /* REG_0x5b:reg0x5b->BASE_WR_LEN:0x5b,ahb memory read len,0x0,R/W*/
jpeg_dec_ll_get_reg0x5b_base_wr_len(void)2472 static inline uint32_t jpeg_dec_ll_get_reg0x5b_base_wr_len(void)
2473 {
2474 return REG_READ(JPEG_DEC_REG0X5B_ADDR);
2475 }
2476
jpeg_dec_ll_set_reg0x5b_base_wr_len(uint32_t value)2477 static inline void jpeg_dec_ll_set_reg0x5b_base_wr_len(uint32_t value)
2478 {
2479 REG_WRITE(JPEG_DEC_REG0X5B_ADDR,value);
2480 }
2481
2482 /* REG_0x5C */
2483 #define JPEG_DEC_REG0X5C_ADDR (JPEG_DEC_LL_REG_BASE + 0x5C*4) //REG ADDR :0x48040170
2484 #define JPEG_DEC_REG0X5C_BASE_FFDA_POS (0)
2485 #define JPEG_DEC_REG0X5C_BASE_FFDA_MASK (0xFFFFFFFF)
2486
jpeg_dec_ll_get_reg0x5c_value(void)2487 static inline uint32_t jpeg_dec_ll_get_reg0x5c_value(void)
2488 {
2489 return REG_READ(JPEG_DEC_REG0X5C_ADDR);
2490 }
2491
jpeg_dec_ll_set_reg0x5c_value(uint32_t value)2492 static inline void jpeg_dec_ll_set_reg0x5c_value(uint32_t value)
2493 {
2494 REG_WRITE(JPEG_DEC_REG0X5C_ADDR,value);
2495 }
2496
2497 /* REG_0x5c:reg0x5c->BASE_FFDA:0x5c,ahb memory ffda addr from BASE_RADDR,0x0,R/W*/
jpeg_dec_ll_get_reg0x5c_base_ffda(void)2498 static inline uint32_t jpeg_dec_ll_get_reg0x5c_base_ffda(void)
2499 {
2500 return REG_READ(JPEG_DEC_REG0X5C_ADDR);
2501 }
2502
jpeg_dec_ll_set_reg0x5c_base_ffda(uint32_t value)2503 static inline void jpeg_dec_ll_set_reg0x5c_base_ffda(uint32_t value)
2504 {
2505 REG_WRITE(JPEG_DEC_REG0X5C_ADDR,value);
2506 }
2507
2508 /* REG_0x5D */
2509 #define JPEG_DEC_REG0X5D_ADDR (JPEG_DEC_LL_REG_BASE + 0x5D*4) //REG ADDR :0x48040174
2510 #define JPEG_DEC_REG0X5D_MASTER_RD_CNT_POS (0)
2511 #define JPEG_DEC_REG0X5D_MASTER_RD_CNT_MASK (0xFFFFFFFF)
2512
jpeg_dec_ll_get_reg0x5d_value(void)2513 static inline uint32_t jpeg_dec_ll_get_reg0x5d_value(void)
2514 {
2515 return REG_READ(JPEG_DEC_REG0X5D_ADDR);
2516 }
2517
2518 /* REG_0x5d:reg0x5d->master_rd_cnt:0x5d,master read count,0x0,R*/
jpeg_dec_ll_get_reg0x5d_master_rd_cnt(void)2519 static inline uint32_t jpeg_dec_ll_get_reg0x5d_master_rd_cnt(void)
2520 {
2521 return REG_READ(JPEG_DEC_REG0X5D_ADDR);
2522 }
2523
2524 /* REG_0x5E */
2525 #define JPEG_DEC_REG0X5E_ADDR (JPEG_DEC_LL_REG_BASE + 0x5E*4) //REG ADDR :0x48040178
2526 #define JPEG_DEC_REG0X5E_DEC_BUSY_INT_POS (0)
2527 #define JPEG_DEC_REG0X5E_DEC_BUSY_INT_MASK (0x1)
2528
2529 #define JPEG_DEC_REG0X5E_DEC_RRLOAD_INT_POS (1)
2530 #define JPEG_DEC_REG0X5E_DEC_RRLOAD_INT_MASK (0x1)
2531
2532 #define JPEG_DEC_REG0X5E_DEC_RLOAD_INT_POS (2)
2533 #define JPEG_DEC_REG0X5E_DEC_RLOAD_INT_MASK (0x1)
2534
2535 #define JPEG_DEC_REG0X5E_DEC_SEARCH_INT_POS (3)
2536 #define JPEG_DEC_REG0X5E_DEC_SEARCH_INT_MASK (0x1)
2537
2538 #define JPEG_DEC_REG0X5E_DEC_EXT_RELOAD_INT_POS (4)
2539 #define JPEG_DEC_REG0X5E_DEC_EXT_RELOAD_INT_MASK (0x1)
2540
2541 #define JPEG_DEC_REG0X5E_DEC_EXT_BIT_INT_POS (5)
2542 #define JPEG_DEC_REG0X5E_DEC_EXT_BIT_INT_MASK (0x1)
2543
2544 #define JPEG_DEC_REG0X5E_DEC_TOTALBUSY_INT_POS (6)
2545 #define JPEG_DEC_REG0X5E_DEC_TOTALBUSY_INT_MASK (0x1)
2546
2547 #define JPEG_DEC_REG0X5E_DEC_MCUFINISH_INT_POS (7)
2548 #define JPEG_DEC_REG0X5E_DEC_MCUFINISH_INT_MASK (0x1)
2549
2550 #define JPEG_DEC_REG0X5E_DEC_FRAME_INT_POS (8)
2551 #define JPEG_DEC_REG0X5E_DEC_FRAME_INT_MASK (0x1)
2552
2553 #define JPEG_DEC_REG0X5E_RESERVED_POS (9)
2554 #define JPEG_DEC_REG0X5E_RESERVED_MASK (0x7FFFFF)
2555
jpeg_dec_ll_get_reg0x5e_value(void)2556 static inline uint32_t jpeg_dec_ll_get_reg0x5e_value(void)
2557 {
2558 return REG_READ(JPEG_DEC_REG0X5E_ADDR);
2559 }
2560
jpeg_dec_ll_set_reg0x5e_value(uint32_t value)2561 static inline void jpeg_dec_ll_set_reg0x5e_value(uint32_t value)
2562 {
2563 REG_WRITE(JPEG_DEC_REG0X5E_ADDR,value);
2564 }
2565
2566 /* REG_0x5e:reg0x5e->dec_busy_int:0x5e[0],int enable; int_en[0] : dec_busy int; ,0x0,R/W*/
jpeg_dec_ll_get_reg0x5e_dec_busy_int(void)2567 static inline uint32_t jpeg_dec_ll_get_reg0x5e_dec_busy_int(void)
2568 {
2569 uint32_t reg_value;
2570 reg_value = REG_READ(JPEG_DEC_REG0X5E_ADDR);
2571 reg_value = ((reg_value >> JPEG_DEC_REG0X5E_DEC_BUSY_INT_POS) & JPEG_DEC_REG0X5E_DEC_BUSY_INT_MASK);
2572 return reg_value;
2573 }
2574
jpeg_dec_ll_set_reg0x5e_dec_busy_int(uint32_t value)2575 static inline void jpeg_dec_ll_set_reg0x5e_dec_busy_int(uint32_t value)
2576 {
2577 uint32_t reg_value;
2578 reg_value = REG_READ(JPEG_DEC_REG0X5E_ADDR);
2579 reg_value &= ~(JPEG_DEC_REG0X5E_DEC_BUSY_INT_MASK << JPEG_DEC_REG0X5E_DEC_BUSY_INT_POS);
2580 reg_value |= ((value & JPEG_DEC_REG0X5E_DEC_BUSY_INT_MASK) << JPEG_DEC_REG0X5E_DEC_BUSY_INT_POS);
2581 REG_WRITE(JPEG_DEC_REG0X5E_ADDR,reg_value);
2582 }
2583
2584 /* REG_0x5e:reg0x5e->dec_rrload_int:0x5e[1],int_en[1] : dec_rrload int; ,0x0,R/W*/
jpeg_dec_ll_get_reg0x5e_dec_rrload_int(void)2585 static inline uint32_t jpeg_dec_ll_get_reg0x5e_dec_rrload_int(void)
2586 {
2587 uint32_t reg_value;
2588 reg_value = REG_READ(JPEG_DEC_REG0X5E_ADDR);
2589 reg_value = ((reg_value >> JPEG_DEC_REG0X5E_DEC_RRLOAD_INT_POS) & JPEG_DEC_REG0X5E_DEC_RRLOAD_INT_MASK);
2590 return reg_value;
2591 }
2592
jpeg_dec_ll_set_reg0x5e_dec_rrload_int(uint32_t value)2593 static inline void jpeg_dec_ll_set_reg0x5e_dec_rrload_int(uint32_t value)
2594 {
2595 uint32_t reg_value;
2596 reg_value = REG_READ(JPEG_DEC_REG0X5E_ADDR);
2597 reg_value &= ~(JPEG_DEC_REG0X5E_DEC_RRLOAD_INT_MASK << JPEG_DEC_REG0X5E_DEC_RRLOAD_INT_POS);
2598 reg_value |= ((value & JPEG_DEC_REG0X5E_DEC_RRLOAD_INT_MASK) << JPEG_DEC_REG0X5E_DEC_RRLOAD_INT_POS);
2599 REG_WRITE(JPEG_DEC_REG0X5E_ADDR,reg_value);
2600 }
2601
2602 /* REG_0x5e:reg0x5e->dec_rload_int:0x5e[2],int_en[2] : dec_rload int; ,0x0,R/W*/
jpeg_dec_ll_get_reg0x5e_dec_rload_int(void)2603 static inline uint32_t jpeg_dec_ll_get_reg0x5e_dec_rload_int(void)
2604 {
2605 uint32_t reg_value;
2606 reg_value = REG_READ(JPEG_DEC_REG0X5E_ADDR);
2607 reg_value = ((reg_value >> JPEG_DEC_REG0X5E_DEC_RLOAD_INT_POS) & JPEG_DEC_REG0X5E_DEC_RLOAD_INT_MASK);
2608 return reg_value;
2609 }
2610
jpeg_dec_ll_set_reg0x5e_dec_rload_int(uint32_t value)2611 static inline void jpeg_dec_ll_set_reg0x5e_dec_rload_int(uint32_t value)
2612 {
2613 uint32_t reg_value;
2614 reg_value = REG_READ(JPEG_DEC_REG0X5E_ADDR);
2615 reg_value &= ~(JPEG_DEC_REG0X5E_DEC_RLOAD_INT_MASK << JPEG_DEC_REG0X5E_DEC_RLOAD_INT_POS);
2616 reg_value |= ((value & JPEG_DEC_REG0X5E_DEC_RLOAD_INT_MASK) << JPEG_DEC_REG0X5E_DEC_RLOAD_INT_POS);
2617 REG_WRITE(JPEG_DEC_REG0X5E_ADDR,reg_value);
2618 }
2619
2620 /* REG_0x5e:reg0x5e->dec_search_int:0x5e[3],int_en[3] : dec_search int; ,0x0,R/W*/
jpeg_dec_ll_get_reg0x5e_dec_search_int(void)2621 static inline uint32_t jpeg_dec_ll_get_reg0x5e_dec_search_int(void)
2622 {
2623 uint32_t reg_value;
2624 reg_value = REG_READ(JPEG_DEC_REG0X5E_ADDR);
2625 reg_value = ((reg_value >> JPEG_DEC_REG0X5E_DEC_SEARCH_INT_POS) & JPEG_DEC_REG0X5E_DEC_SEARCH_INT_MASK);
2626 return reg_value;
2627 }
2628
jpeg_dec_ll_set_reg0x5e_dec_search_int(uint32_t value)2629 static inline void jpeg_dec_ll_set_reg0x5e_dec_search_int(uint32_t value)
2630 {
2631 uint32_t reg_value;
2632 reg_value = REG_READ(JPEG_DEC_REG0X5E_ADDR);
2633 reg_value &= ~(JPEG_DEC_REG0X5E_DEC_SEARCH_INT_MASK << JPEG_DEC_REG0X5E_DEC_SEARCH_INT_POS);
2634 reg_value |= ((value & JPEG_DEC_REG0X5E_DEC_SEARCH_INT_MASK) << JPEG_DEC_REG0X5E_DEC_SEARCH_INT_POS);
2635 REG_WRITE(JPEG_DEC_REG0X5E_ADDR,reg_value);
2636 }
2637
2638 /* REG_0x5e:reg0x5e->dec_ext_reload_int:0x5e[4],int_en[4] : dec_ext_reload int; ,0x0,R/W*/
jpeg_dec_ll_get_reg0x5e_dec_ext_reload_int(void)2639 static inline uint32_t jpeg_dec_ll_get_reg0x5e_dec_ext_reload_int(void)
2640 {
2641 uint32_t reg_value;
2642 reg_value = REG_READ(JPEG_DEC_REG0X5E_ADDR);
2643 reg_value = ((reg_value >> JPEG_DEC_REG0X5E_DEC_EXT_RELOAD_INT_POS) & JPEG_DEC_REG0X5E_DEC_EXT_RELOAD_INT_MASK);
2644 return reg_value;
2645 }
2646
jpeg_dec_ll_set_reg0x5e_dec_ext_reload_int(uint32_t value)2647 static inline void jpeg_dec_ll_set_reg0x5e_dec_ext_reload_int(uint32_t value)
2648 {
2649 uint32_t reg_value;
2650 reg_value = REG_READ(JPEG_DEC_REG0X5E_ADDR);
2651 reg_value &= ~(JPEG_DEC_REG0X5E_DEC_EXT_RELOAD_INT_MASK << JPEG_DEC_REG0X5E_DEC_EXT_RELOAD_INT_POS);
2652 reg_value |= ((value & JPEG_DEC_REG0X5E_DEC_EXT_RELOAD_INT_MASK) << JPEG_DEC_REG0X5E_DEC_EXT_RELOAD_INT_POS);
2653 REG_WRITE(JPEG_DEC_REG0X5E_ADDR,reg_value);
2654 }
2655
2656 /* REG_0x5e:reg0x5e->dec_ext_bit_int:0x5e[5],int_en[5] : dec_ext_bit int; ,0x0,R/W*/
jpeg_dec_ll_get_reg0x5e_dec_ext_bit_int(void)2657 static inline uint32_t jpeg_dec_ll_get_reg0x5e_dec_ext_bit_int(void)
2658 {
2659 uint32_t reg_value;
2660 reg_value = REG_READ(JPEG_DEC_REG0X5E_ADDR);
2661 reg_value = ((reg_value >> JPEG_DEC_REG0X5E_DEC_EXT_BIT_INT_POS) & JPEG_DEC_REG0X5E_DEC_EXT_BIT_INT_MASK);
2662 return reg_value;
2663 }
2664
jpeg_dec_ll_set_reg0x5e_dec_ext_bit_int(uint32_t value)2665 static inline void jpeg_dec_ll_set_reg0x5e_dec_ext_bit_int(uint32_t value)
2666 {
2667 uint32_t reg_value;
2668 reg_value = REG_READ(JPEG_DEC_REG0X5E_ADDR);
2669 reg_value &= ~(JPEG_DEC_REG0X5E_DEC_EXT_BIT_INT_MASK << JPEG_DEC_REG0X5E_DEC_EXT_BIT_INT_POS);
2670 reg_value |= ((value & JPEG_DEC_REG0X5E_DEC_EXT_BIT_INT_MASK) << JPEG_DEC_REG0X5E_DEC_EXT_BIT_INT_POS);
2671 REG_WRITE(JPEG_DEC_REG0X5E_ADDR,reg_value);
2672 }
2673
2674 /* REG_0x5e:reg0x5e->dec_totalbusy_int:0x5e[6],int_en[6] : dec_totalbusy int //line en dec; ,0x0,R/W*/
jpeg_dec_ll_get_reg0x5e_dec_totalbusy_int(void)2675 static inline uint32_t jpeg_dec_ll_get_reg0x5e_dec_totalbusy_int(void)
2676 {
2677 uint32_t reg_value;
2678 reg_value = REG_READ(JPEG_DEC_REG0X5E_ADDR);
2679 reg_value = ((reg_value >> JPEG_DEC_REG0X5E_DEC_TOTALBUSY_INT_POS) & JPEG_DEC_REG0X5E_DEC_TOTALBUSY_INT_MASK);
2680 return reg_value;
2681 }
2682
jpeg_dec_ll_set_reg0x5e_dec_totalbusy_int(uint32_t value)2683 static inline void jpeg_dec_ll_set_reg0x5e_dec_totalbusy_int(uint32_t value)
2684 {
2685 uint32_t reg_value;
2686 reg_value = REG_READ(JPEG_DEC_REG0X5E_ADDR);
2687 reg_value &= ~(JPEG_DEC_REG0X5E_DEC_TOTALBUSY_INT_MASK << JPEG_DEC_REG0X5E_DEC_TOTALBUSY_INT_POS);
2688 reg_value |= ((value & JPEG_DEC_REG0X5E_DEC_TOTALBUSY_INT_MASK) << JPEG_DEC_REG0X5E_DEC_TOTALBUSY_INT_POS);
2689 REG_WRITE(JPEG_DEC_REG0X5E_ADDR,reg_value);
2690 }
2691
2692 /* REG_0x5e:reg0x5e->dec_mcufinish_int:0x5e[7],int_en[7] : dec_mcufinish int; ,0x0,R/W*/
jpeg_dec_ll_get_reg0x5e_dec_mcufinish_int(void)2693 static inline uint32_t jpeg_dec_ll_get_reg0x5e_dec_mcufinish_int(void)
2694 {
2695 uint32_t reg_value;
2696 reg_value = REG_READ(JPEG_DEC_REG0X5E_ADDR);
2697 reg_value = ((reg_value >> JPEG_DEC_REG0X5E_DEC_MCUFINISH_INT_POS) & JPEG_DEC_REG0X5E_DEC_MCUFINISH_INT_MASK);
2698 return reg_value;
2699 }
2700
jpeg_dec_ll_set_reg0x5e_dec_mcufinish_int(uint32_t value)2701 static inline void jpeg_dec_ll_set_reg0x5e_dec_mcufinish_int(uint32_t value)
2702 {
2703 uint32_t reg_value;
2704 reg_value = REG_READ(JPEG_DEC_REG0X5E_ADDR);
2705 reg_value &= ~(JPEG_DEC_REG0X5E_DEC_MCUFINISH_INT_MASK << JPEG_DEC_REG0X5E_DEC_MCUFINISH_INT_POS);
2706 reg_value |= ((value & JPEG_DEC_REG0X5E_DEC_MCUFINISH_INT_MASK) << JPEG_DEC_REG0X5E_DEC_MCUFINISH_INT_POS);
2707 REG_WRITE(JPEG_DEC_REG0X5E_ADDR,reg_value);
2708 }
2709
2710 /* REG_0x5e:reg0x5e->dec_frame_int:0x5e[8],int_en[8] : dec_frame int //auto dec,0x0,R/W*/
jpeg_dec_ll_get_reg0x5e_dec_frame_int(void)2711 static inline uint32_t jpeg_dec_ll_get_reg0x5e_dec_frame_int(void)
2712 {
2713 uint32_t reg_value;
2714 reg_value = REG_READ(JPEG_DEC_REG0X5E_ADDR);
2715 reg_value = ((reg_value >> JPEG_DEC_REG0X5E_DEC_FRAME_INT_POS) & JPEG_DEC_REG0X5E_DEC_FRAME_INT_MASK);
2716 return reg_value;
2717 }
2718
jpeg_dec_ll_set_reg0x5e_dec_frame_int(uint32_t value)2719 static inline void jpeg_dec_ll_set_reg0x5e_dec_frame_int(uint32_t value)
2720 {
2721 uint32_t reg_value;
2722 reg_value = REG_READ(JPEG_DEC_REG0X5E_ADDR);
2723 reg_value &= ~(JPEG_DEC_REG0X5E_DEC_FRAME_INT_MASK << JPEG_DEC_REG0X5E_DEC_FRAME_INT_POS);
2724 reg_value |= ((value & JPEG_DEC_REG0X5E_DEC_FRAME_INT_MASK) << JPEG_DEC_REG0X5E_DEC_FRAME_INT_POS);
2725 REG_WRITE(JPEG_DEC_REG0X5E_ADDR,reg_value);
2726 }
2727
2728 /* REG_0x5F */
2729 #define JPEG_DEC_REG0X5F_ADDR (JPEG_DEC_LL_REG_BASE + 0x5F*4) //REG ADDR :0x4804017c
2730 #define JPEG_DEC_REG0X5F_DEC_BUSY_INT_CLR_POS (0)
2731 #define JPEG_DEC_REG0X5F_DEC_BUSY_INT_CLR_MASK (0x1)
2732
2733 #define JPEG_DEC_REG0X5F_DEC_RRLOAD_INT_CLR_POS (1)
2734 #define JPEG_DEC_REG0X5F_DEC_RRLOAD_INT_CLR_MASK (0x1)
2735
2736 #define JPEG_DEC_REG0X5F_DEC_RLOAD_INT_CLR_POS (2)
2737 #define JPEG_DEC_REG0X5F_DEC_RLOAD_INT_CLR_MASK (0x1)
2738
2739 #define JPEG_DEC_REG0X5F_DEC_SEARCH_INT_CLR_POS (3)
2740 #define JPEG_DEC_REG0X5F_DEC_SEARCH_INT_CLR_MASK (0x1)
2741
2742 #define JPEG_DEC_REG0X5F_DEC_EXT_RELOAD_INT_CLR_POS (4)
2743 #define JPEG_DEC_REG0X5F_DEC_EXT_RELOAD_INT_CLR_MASK (0x1)
2744
2745 #define JPEG_DEC_REG0X5F_DEC_EXT_BIT_INT_CLR_POS (5)
2746 #define JPEG_DEC_REG0X5F_DEC_EXT_BIT_INT_CLR_MASK (0x1)
2747
2748 #define JPEG_DEC_REG0X5F_DEC_TOTALBUSY_INT_CLR_POS (6)
2749 #define JPEG_DEC_REG0X5F_DEC_TOTALBUSY_INT_CLR_MASK (0x1)
2750
2751 #define JPEG_DEC_REG0X5F_DEC_MCUFINISH_INT_CLR_POS (7)
2752 #define JPEG_DEC_REG0X5F_DEC_MCUFINISH_INT_CLR_MASK (0x1)
2753
2754 #define JPEG_DEC_REG0X5F_DEC_FRAME_INT_CLR_POS (8)
2755 #define JPEG_DEC_REG0X5F_DEC_FRAME_INT_CLR_MASK (0x1)
2756
2757 #define JPEG_DEC_REG0X5F_RESERVED0_POS (9)
2758 #define JPEG_DEC_REG0X5F_RESERVED0_MASK (0x7FFFFF)
2759
jpeg_dec_ll_get_reg0x5f_value(void)2760 static inline uint32_t jpeg_dec_ll_get_reg0x5f_value(void)
2761 {
2762 return REG_READ(JPEG_DEC_REG0X5F_ADDR);
2763 }
2764
jpeg_dec_ll_set_reg0x5f_value(uint32_t value)2765 static inline void jpeg_dec_ll_set_reg0x5f_value(uint32_t value)
2766 {
2767 REG_WRITE(JPEG_DEC_REG0X5F_ADDR,value);
2768 }
2769
2770 /* REG_0x5f:reg0x5f->dec_busy_int_clr:0x5f[0],int enable; int_en[0] : dec_busy int; ,0x0,R/W*/
jpeg_dec_ll_get_reg0x5f_dec_busy_int_clr(void)2771 static inline uint32_t jpeg_dec_ll_get_reg0x5f_dec_busy_int_clr(void)
2772 {
2773 uint32_t reg_value;
2774 reg_value = REG_READ(JPEG_DEC_REG0X5F_ADDR);
2775 reg_value = ((reg_value >> JPEG_DEC_REG0X5F_DEC_BUSY_INT_CLR_POS) & JPEG_DEC_REG0X5F_DEC_BUSY_INT_CLR_MASK);
2776 return reg_value;
2777 }
2778
jpeg_dec_ll_set_reg0x5f_dec_busy_int_clr(uint32_t value)2779 static inline void jpeg_dec_ll_set_reg0x5f_dec_busy_int_clr(uint32_t value)
2780 {
2781 uint32_t reg_value;
2782 reg_value = REG_READ(JPEG_DEC_REG0X5F_ADDR);
2783 reg_value &= ~(JPEG_DEC_REG0X5F_DEC_BUSY_INT_CLR_MASK << JPEG_DEC_REG0X5F_DEC_BUSY_INT_CLR_POS);
2784 reg_value |= ((value & JPEG_DEC_REG0X5F_DEC_BUSY_INT_CLR_MASK) << JPEG_DEC_REG0X5F_DEC_BUSY_INT_CLR_POS);
2785 REG_WRITE(JPEG_DEC_REG0X5F_ADDR,reg_value);
2786 }
2787
2788 /* REG_0x5f:reg0x5f->dec_rrload_int_clr:0x5f[1],int_en[1] : dec_rrload int; ,0x0,R/W*/
jpeg_dec_ll_get_reg0x5f_dec_rrload_int_clr(void)2789 static inline uint32_t jpeg_dec_ll_get_reg0x5f_dec_rrload_int_clr(void)
2790 {
2791 uint32_t reg_value;
2792 reg_value = REG_READ(JPEG_DEC_REG0X5F_ADDR);
2793 reg_value = ((reg_value >> JPEG_DEC_REG0X5F_DEC_RRLOAD_INT_CLR_POS) & JPEG_DEC_REG0X5F_DEC_RRLOAD_INT_CLR_MASK);
2794 return reg_value;
2795 }
2796
jpeg_dec_ll_set_reg0x5f_dec_rrload_int_clr(uint32_t value)2797 static inline void jpeg_dec_ll_set_reg0x5f_dec_rrload_int_clr(uint32_t value)
2798 {
2799 uint32_t reg_value;
2800 reg_value = REG_READ(JPEG_DEC_REG0X5F_ADDR);
2801 reg_value &= ~(JPEG_DEC_REG0X5F_DEC_RRLOAD_INT_CLR_MASK << JPEG_DEC_REG0X5F_DEC_RRLOAD_INT_CLR_POS);
2802 reg_value |= ((value & JPEG_DEC_REG0X5F_DEC_RRLOAD_INT_CLR_MASK) << JPEG_DEC_REG0X5F_DEC_RRLOAD_INT_CLR_POS);
2803 REG_WRITE(JPEG_DEC_REG0X5F_ADDR,reg_value);
2804 }
2805
2806 /* REG_0x5f:reg0x5f->dec_rload_int_clr:0x5f[2],int_en[2] : dec_rload int; ,0x0,R/W*/
jpeg_dec_ll_get_reg0x5f_dec_rload_int_clr(void)2807 static inline uint32_t jpeg_dec_ll_get_reg0x5f_dec_rload_int_clr(void)
2808 {
2809 uint32_t reg_value;
2810 reg_value = REG_READ(JPEG_DEC_REG0X5F_ADDR);
2811 reg_value = ((reg_value >> JPEG_DEC_REG0X5F_DEC_RLOAD_INT_CLR_POS) & JPEG_DEC_REG0X5F_DEC_RLOAD_INT_CLR_MASK);
2812 return reg_value;
2813 }
2814
jpeg_dec_ll_set_reg0x5f_dec_rload_int_clr(uint32_t value)2815 static inline void jpeg_dec_ll_set_reg0x5f_dec_rload_int_clr(uint32_t value)
2816 {
2817 uint32_t reg_value;
2818 reg_value = REG_READ(JPEG_DEC_REG0X5F_ADDR);
2819 reg_value &= ~(JPEG_DEC_REG0X5F_DEC_RLOAD_INT_CLR_MASK << JPEG_DEC_REG0X5F_DEC_RLOAD_INT_CLR_POS);
2820 reg_value |= ((value & JPEG_DEC_REG0X5F_DEC_RLOAD_INT_CLR_MASK) << JPEG_DEC_REG0X5F_DEC_RLOAD_INT_CLR_POS);
2821 REG_WRITE(JPEG_DEC_REG0X5F_ADDR,reg_value);
2822 }
2823
2824 /* REG_0x5f:reg0x5f->dec_search_int_clr:0x5f[3],int_en[3] : dec_search int; ,0x0,R/W*/
jpeg_dec_ll_get_reg0x5f_dec_search_int_clr(void)2825 static inline uint32_t jpeg_dec_ll_get_reg0x5f_dec_search_int_clr(void)
2826 {
2827 uint32_t reg_value;
2828 reg_value = REG_READ(JPEG_DEC_REG0X5F_ADDR);
2829 reg_value = ((reg_value >> JPEG_DEC_REG0X5F_DEC_SEARCH_INT_CLR_POS) & JPEG_DEC_REG0X5F_DEC_SEARCH_INT_CLR_MASK);
2830 return reg_value;
2831 }
2832
jpeg_dec_ll_set_reg0x5f_dec_search_int_clr(uint32_t value)2833 static inline void jpeg_dec_ll_set_reg0x5f_dec_search_int_clr(uint32_t value)
2834 {
2835 uint32_t reg_value;
2836 reg_value = REG_READ(JPEG_DEC_REG0X5F_ADDR);
2837 reg_value &= ~(JPEG_DEC_REG0X5F_DEC_SEARCH_INT_CLR_MASK << JPEG_DEC_REG0X5F_DEC_SEARCH_INT_CLR_POS);
2838 reg_value |= ((value & JPEG_DEC_REG0X5F_DEC_SEARCH_INT_CLR_MASK) << JPEG_DEC_REG0X5F_DEC_SEARCH_INT_CLR_POS);
2839 REG_WRITE(JPEG_DEC_REG0X5F_ADDR,reg_value);
2840 }
2841
2842 /* REG_0x5f:reg0x5f->dec_ext_reload_int_clr:0x5f[4],int_en[4] : dec_ext_reload int; ,0x0,R/W*/
jpeg_dec_ll_get_reg0x5f_dec_ext_reload_int_clr(void)2843 static inline uint32_t jpeg_dec_ll_get_reg0x5f_dec_ext_reload_int_clr(void)
2844 {
2845 uint32_t reg_value;
2846 reg_value = REG_READ(JPEG_DEC_REG0X5F_ADDR);
2847 reg_value = ((reg_value >> JPEG_DEC_REG0X5F_DEC_EXT_RELOAD_INT_CLR_POS) & JPEG_DEC_REG0X5F_DEC_EXT_RELOAD_INT_CLR_MASK);
2848 return reg_value;
2849 }
2850
jpeg_dec_ll_set_reg0x5f_dec_ext_reload_int_clr(uint32_t value)2851 static inline void jpeg_dec_ll_set_reg0x5f_dec_ext_reload_int_clr(uint32_t value)
2852 {
2853 uint32_t reg_value;
2854 reg_value = REG_READ(JPEG_DEC_REG0X5F_ADDR);
2855 reg_value &= ~(JPEG_DEC_REG0X5F_DEC_EXT_RELOAD_INT_CLR_MASK << JPEG_DEC_REG0X5F_DEC_EXT_RELOAD_INT_CLR_POS);
2856 reg_value |= ((value & JPEG_DEC_REG0X5F_DEC_EXT_RELOAD_INT_CLR_MASK) << JPEG_DEC_REG0X5F_DEC_EXT_RELOAD_INT_CLR_POS);
2857 REG_WRITE(JPEG_DEC_REG0X5F_ADDR,reg_value);
2858 }
2859
2860 /* REG_0x5f:reg0x5f->dec_ext_bit_int_clr:0x5f[5],int_en[5] : dec_ext_bit int; ,0x0,R/W*/
jpeg_dec_ll_get_reg0x5f_dec_ext_bit_int_clr(void)2861 static inline uint32_t jpeg_dec_ll_get_reg0x5f_dec_ext_bit_int_clr(void)
2862 {
2863 uint32_t reg_value;
2864 reg_value = REG_READ(JPEG_DEC_REG0X5F_ADDR);
2865 reg_value = ((reg_value >> JPEG_DEC_REG0X5F_DEC_EXT_BIT_INT_CLR_POS) & JPEG_DEC_REG0X5F_DEC_EXT_BIT_INT_CLR_MASK);
2866 return reg_value;
2867 }
2868
jpeg_dec_ll_set_reg0x5f_dec_ext_bit_int_clr(uint32_t value)2869 static inline void jpeg_dec_ll_set_reg0x5f_dec_ext_bit_int_clr(uint32_t value)
2870 {
2871 uint32_t reg_value;
2872 reg_value = REG_READ(JPEG_DEC_REG0X5F_ADDR);
2873 reg_value &= ~(JPEG_DEC_REG0X5F_DEC_EXT_BIT_INT_CLR_MASK << JPEG_DEC_REG0X5F_DEC_EXT_BIT_INT_CLR_POS);
2874 reg_value |= ((value & JPEG_DEC_REG0X5F_DEC_EXT_BIT_INT_CLR_MASK) << JPEG_DEC_REG0X5F_DEC_EXT_BIT_INT_CLR_POS);
2875 REG_WRITE(JPEG_DEC_REG0X5F_ADDR,reg_value);
2876 }
2877
2878 /* REG_0x5f:reg0x5f->dec_totalbusy_int_clr:0x5f[6],int_en[6] : dec_totalbusy int //line en dec; ,0x0,R/W*/
jpeg_dec_ll_get_reg0x5f_dec_totalbusy_int_clr(void)2879 static inline uint32_t jpeg_dec_ll_get_reg0x5f_dec_totalbusy_int_clr(void)
2880 {
2881 uint32_t reg_value;
2882 reg_value = REG_READ(JPEG_DEC_REG0X5F_ADDR);
2883 reg_value = ((reg_value >> JPEG_DEC_REG0X5F_DEC_TOTALBUSY_INT_CLR_POS) & JPEG_DEC_REG0X5F_DEC_TOTALBUSY_INT_CLR_MASK);
2884 return reg_value;
2885 }
2886
jpeg_dec_ll_set_reg0x5f_dec_totalbusy_int_clr(uint32_t value)2887 static inline void jpeg_dec_ll_set_reg0x5f_dec_totalbusy_int_clr(uint32_t value)
2888 {
2889 uint32_t reg_value;
2890 reg_value = REG_READ(JPEG_DEC_REG0X5F_ADDR);
2891 reg_value &= ~(JPEG_DEC_REG0X5F_DEC_TOTALBUSY_INT_CLR_MASK << JPEG_DEC_REG0X5F_DEC_TOTALBUSY_INT_CLR_POS);
2892 reg_value |= ((value & JPEG_DEC_REG0X5F_DEC_TOTALBUSY_INT_CLR_MASK) << JPEG_DEC_REG0X5F_DEC_TOTALBUSY_INT_CLR_POS);
2893 REG_WRITE(JPEG_DEC_REG0X5F_ADDR,reg_value);
2894 }
2895
2896 /* REG_0x5f:reg0x5f->dec_mcufinish_int_clr:0x5f[7],int_en[7] : dec_mcufinish int; ,0x0,R/W*/
jpeg_dec_ll_get_reg0x5f_dec_mcufinish_int_clr(void)2897 static inline uint32_t jpeg_dec_ll_get_reg0x5f_dec_mcufinish_int_clr(void)
2898 {
2899 uint32_t reg_value;
2900 reg_value = REG_READ(JPEG_DEC_REG0X5F_ADDR);
2901 reg_value = ((reg_value >> JPEG_DEC_REG0X5F_DEC_MCUFINISH_INT_CLR_POS) & JPEG_DEC_REG0X5F_DEC_MCUFINISH_INT_CLR_MASK);
2902 return reg_value;
2903 }
2904
jpeg_dec_ll_set_reg0x5f_dec_mcufinish_int_clr(uint32_t value)2905 static inline void jpeg_dec_ll_set_reg0x5f_dec_mcufinish_int_clr(uint32_t value)
2906 {
2907 uint32_t reg_value;
2908 reg_value = REG_READ(JPEG_DEC_REG0X5F_ADDR);
2909 reg_value &= ~(JPEG_DEC_REG0X5F_DEC_MCUFINISH_INT_CLR_MASK << JPEG_DEC_REG0X5F_DEC_MCUFINISH_INT_CLR_POS);
2910 reg_value |= ((value & JPEG_DEC_REG0X5F_DEC_MCUFINISH_INT_CLR_MASK) << JPEG_DEC_REG0X5F_DEC_MCUFINISH_INT_CLR_POS);
2911 REG_WRITE(JPEG_DEC_REG0X5F_ADDR,reg_value);
2912 }
2913
2914 /* REG_0x5f:reg0x5f->dec_frame_int_clr:0x5f[8],int_en[8] : dec_frame int //auto dec,0x0,R/W*/
jpeg_dec_ll_get_reg0x5f_dec_frame_int_clr(void)2915 static inline uint32_t jpeg_dec_ll_get_reg0x5f_dec_frame_int_clr(void)
2916 {
2917 uint32_t reg_value;
2918 reg_value = REG_READ(JPEG_DEC_REG0X5F_ADDR);
2919 reg_value = ((reg_value >> JPEG_DEC_REG0X5F_DEC_FRAME_INT_CLR_POS) & JPEG_DEC_REG0X5F_DEC_FRAME_INT_CLR_MASK);
2920 return reg_value;
2921 }
2922
jpeg_dec_ll_set_reg0x5f_dec_frame_int_clr(uint32_t value)2923 static inline void jpeg_dec_ll_set_reg0x5f_dec_frame_int_clr(uint32_t value)
2924 {
2925 uint32_t reg_value;
2926 reg_value = REG_READ(JPEG_DEC_REG0X5F_ADDR);
2927 reg_value &= ~(JPEG_DEC_REG0X5F_DEC_FRAME_INT_CLR_MASK << JPEG_DEC_REG0X5F_DEC_FRAME_INT_CLR_POS);
2928 reg_value |= ((value & JPEG_DEC_REG0X5F_DEC_FRAME_INT_CLR_MASK) << JPEG_DEC_REG0X5F_DEC_FRAME_INT_CLR_POS);
2929 REG_WRITE(JPEG_DEC_REG0X5F_ADDR,reg_value);
2930 }
2931
2932 /* REG_0x80 */
2933 #define JPEG_DEC_REG0X80_ADDR (JPEG_DEC_LL_REG_BASE + 0x80*4) //REG ADDR :0x48040200
2934 #define JPEG_DEC_REG0X80_HUFDC_Y_POS (0)
2935 #define JPEG_DEC_REG0X80_HUFDC_Y_MASK (0xFFFFFFFF)
2936
jpeg_dec_ll_get_reg0x80_value(void)2937 static inline uint32_t jpeg_dec_ll_get_reg0x80_value(void)
2938 {
2939 return REG_READ(JPEG_DEC_REG0X80_ADDR);
2940 }
2941
jpeg_dec_ll_set_reg0x80_value(uint32_t value)2942 static inline void jpeg_dec_ll_set_reg0x80_value(uint32_t value)
2943 {
2944 REG_WRITE(JPEG_DEC_REG0X80_ADDR,value);
2945 }
2946
2947 /* REG_0x80:reg0x80->hufdc_y:0x80,huffman table dc of y,0x0,R/W*/
jpeg_dec_ll_get_reg0x80_hufdc_y(void)2948 static inline uint32_t jpeg_dec_ll_get_reg0x80_hufdc_y(void)
2949 {
2950 return REG_READ(JPEG_DEC_REG0X80_ADDR);
2951 }
2952
jpeg_dec_ll_set_reg0x80_hufdc_y(uint32_t value)2953 static inline void jpeg_dec_ll_set_reg0x80_hufdc_y(uint32_t value)
2954 {
2955 REG_WRITE(JPEG_DEC_REG0X80_ADDR,value);
2956 }
2957
2958 /* REG_0xC0 */
2959 #define JPEG_DEC_REG0XC0_ADDR (JPEG_DEC_LL_REG_BASE + 0xC0*4) //REG ADDR :0x48040300
2960 #define JPEG_DEC_REG0XC0_HUFDC_UV_POS (0)
2961 #define JPEG_DEC_REG0XC0_HUFDC_UV_MASK (0xFFFFFFFF)
2962
jpeg_dec_ll_get_reg0xc0_value(void)2963 static inline uint32_t jpeg_dec_ll_get_reg0xc0_value(void)
2964 {
2965 return REG_READ(JPEG_DEC_REG0XC0_ADDR);
2966 }
2967
jpeg_dec_ll_set_reg0xc0_value(uint32_t value)2968 static inline void jpeg_dec_ll_set_reg0xc0_value(uint32_t value)
2969 {
2970 REG_WRITE(JPEG_DEC_REG0XC0_ADDR,value);
2971 }
2972
2973 /* REG_0xc0:reg0xc0->hufdc_uv:0xc0,huffman table dc of uv,0x0,R/W*/
jpeg_dec_ll_get_reg0xc0_hufdc_uv(void)2974 static inline uint32_t jpeg_dec_ll_get_reg0xc0_hufdc_uv(void)
2975 {
2976 return REG_READ(JPEG_DEC_REG0XC0_ADDR);
2977 }
2978
jpeg_dec_ll_set_reg0xc0_hufdc_uv(uint32_t value)2979 static inline void jpeg_dec_ll_set_reg0xc0_hufdc_uv(uint32_t value)
2980 {
2981 REG_WRITE(JPEG_DEC_REG0XC0_ADDR,value);
2982 }
2983
2984 /* REG_0x100 */
2985 #define JPEG_DEC_REG0X100_ADDR (JPEG_DEC_LL_REG_BASE + 0x100*4) //REG ADDR :0x48040400
2986 #define JPEG_DEC_REG0X100_HUFAC_Y_POS (0)
2987 #define JPEG_DEC_REG0X100_HUFAC_Y_MASK (0xFFFFFFFF)
2988
jpeg_dec_ll_get_reg0x100_value(void)2989 static inline uint32_t jpeg_dec_ll_get_reg0x100_value(void)
2990 {
2991 return REG_READ(JPEG_DEC_REG0X100_ADDR);
2992 }
2993
jpeg_dec_ll_set_reg0x100_value(uint32_t value)2994 static inline void jpeg_dec_ll_set_reg0x100_value(uint32_t value)
2995 {
2996 REG_WRITE(JPEG_DEC_REG0X100_ADDR,value);
2997 }
2998
2999 /* REG_0x100:reg0x100->hufac_y:0x100,huffman table ac of y,0x0,R/W*/
jpeg_dec_ll_get_reg0x100_hufac_y(void)3000 static inline uint32_t jpeg_dec_ll_get_reg0x100_hufac_y(void)
3001 {
3002 return REG_READ(JPEG_DEC_REG0X100_ADDR);
3003 }
3004
jpeg_dec_ll_set_reg0x100_hufac_y(uint32_t value)3005 static inline void jpeg_dec_ll_set_reg0x100_hufac_y(uint32_t value)
3006 {
3007 REG_WRITE(JPEG_DEC_REG0X100_ADDR,value);
3008 }
3009
3010 /* REG_0x200 */
3011 #define JPEG_DEC_REG0X200_ADDR (JPEG_DEC_LL_REG_BASE + 0x200*4) //REG ADDR :0x48040800
3012 #define JPEG_DEC_REG0X200_HUFAC_UV_POS (0)
3013 #define JPEG_DEC_REG0X200_HUFAC_UV_MASK (0xFFFFFFFF)
3014
jpeg_dec_ll_get_reg0x200_value(void)3015 static inline uint32_t jpeg_dec_ll_get_reg0x200_value(void)
3016 {
3017 return REG_READ(JPEG_DEC_REG0X200_ADDR);
3018 }
3019
jpeg_dec_ll_set_reg0x200_value(uint32_t value)3020 static inline void jpeg_dec_ll_set_reg0x200_value(uint32_t value)
3021 {
3022 REG_WRITE(JPEG_DEC_REG0X200_ADDR,value);
3023 }
3024
3025 /* REG_0x200:reg0x200->hufac_uv:0x200,huffman table ac of uv,0x0,R/W*/
jpeg_dec_ll_get_reg0x200_hufac_uv(void)3026 static inline uint32_t jpeg_dec_ll_get_reg0x200_hufac_uv(void)
3027 {
3028 return REG_READ(JPEG_DEC_REG0X200_ADDR);
3029 }
3030
jpeg_dec_ll_set_reg0x200_hufac_uv(uint32_t value)3031 static inline void jpeg_dec_ll_set_reg0x200_hufac_uv(uint32_t value)
3032 {
3033 REG_WRITE(JPEG_DEC_REG0X200_ADDR,value);
3034 }
3035
3036 /* REG_0x300 */
3037 #define JPEG_DEC_REG0X300_ADDR (JPEG_DEC_LL_REG_BASE + 0x300*4) //REG ADDR :0x48040c00
3038 #define JPEG_DEC_REG0X300_ZIGZAG_BUF_POS (0)
3039 #define JPEG_DEC_REG0X300_ZIGZAG_BUF_MASK (0xFFFFFFFF)
3040
jpeg_dec_ll_get_reg0x300_value(void)3041 static inline uint32_t jpeg_dec_ll_get_reg0x300_value(void)
3042 {
3043 return REG_READ(JPEG_DEC_REG0X300_ADDR);
3044 }
3045
jpeg_dec_ll_set_reg0x300_value(uint32_t value)3046 static inline void jpeg_dec_ll_set_reg0x300_value(uint32_t value)
3047 {
3048 REG_WRITE(JPEG_DEC_REG0X300_ADDR,value);
3049 }
3050
3051 /* REG_0x300:reg0x300->zigzag_buf:0x300,zigzag buf,0x0,R/W*/
jpeg_dec_ll_get_reg0x300_zigzag_buf(void)3052 static inline uint32_t jpeg_dec_ll_get_reg0x300_zigzag_buf(void)
3053 {
3054 return REG_READ(JPEG_DEC_REG0X300_ADDR);
3055 }
3056
jpeg_dec_ll_set_reg0x300_zigzag_buf(uint32_t value)3057 static inline void jpeg_dec_ll_set_reg0x300_zigzag_buf(uint32_t value)
3058 {
3059 REG_WRITE(JPEG_DEC_REG0X300_ADDR,value);
3060 }
3061
3062 /* REG_0x340 */
3063 #define JPEG_DEC_REG0X340_ADDR (JPEG_DEC_LL_REG_BASE + 0x340*4) //REG ADDR :0x48040d00
3064 #define JPEG_DEC_REG0X340_DCT_TEMP_BUF_POS (0)
3065 #define JPEG_DEC_REG0X340_DCT_TEMP_BUF_MASK (0xFFFFFFFF)
3066
jpeg_dec_ll_get_reg0x340_value(void)3067 static inline uint32_t jpeg_dec_ll_get_reg0x340_value(void)
3068 {
3069 return REG_READ(JPEG_DEC_REG0X340_ADDR);
3070 }
3071
jpeg_dec_ll_set_reg0x340_value(uint32_t value)3072 static inline void jpeg_dec_ll_set_reg0x340_value(uint32_t value)
3073 {
3074 REG_WRITE(JPEG_DEC_REG0X340_ADDR,value);
3075 }
3076
3077 /* REG_0x340:reg0x340->dct_temp_buf:0x340,dct_temp_buf,0x0,R/W*/
jpeg_dec_ll_get_reg0x340_dct_temp_buf(void)3078 static inline uint32_t jpeg_dec_ll_get_reg0x340_dct_temp_buf(void)
3079 {
3080 return REG_READ(JPEG_DEC_REG0X340_ADDR);
3081 }
3082
jpeg_dec_ll_set_reg0x340_dct_temp_buf(uint32_t value)3083 static inline void jpeg_dec_ll_set_reg0x340_dct_temp_buf(uint32_t value)
3084 {
3085 REG_WRITE(JPEG_DEC_REG0X340_ADDR,value);
3086 }
3087
3088 /* REG_0x380 */
3089 #define JPEG_DEC_REG0X380_ADDR (JPEG_DEC_LL_REG_BASE + 0x380*4) //REG ADDR :0x48040e00
3090 #define JPEG_DEC_REG0X380_DQT_TABLE_DC_POS (0)
3091 #define JPEG_DEC_REG0X380_DQT_TABLE_DC_MASK (0xFFFFFFFF)
3092
jpeg_dec_ll_get_reg0x380_value(void)3093 static inline uint32_t jpeg_dec_ll_get_reg0x380_value(void)
3094 {
3095 return REG_READ(JPEG_DEC_REG0X380_ADDR);
3096 }
3097
jpeg_dec_ll_set_reg0x380_value(uint32_t value)3098 static inline void jpeg_dec_ll_set_reg0x380_value(uint32_t value)
3099 {
3100 REG_WRITE(JPEG_DEC_REG0X380_ADDR,value);
3101 }
3102
3103 /* REG_0x380:reg0x380->DQT_table_dc:0x380,DQT_table_dc,0x0,R/W*/
jpeg_dec_ll_get_reg0x380_dqt_table_dc(void)3104 static inline uint32_t jpeg_dec_ll_get_reg0x380_dqt_table_dc(void)
3105 {
3106 return REG_READ(JPEG_DEC_REG0X380_ADDR);
3107 }
3108
jpeg_dec_ll_set_reg0x380_dqt_table_dc(uint32_t value)3109 static inline void jpeg_dec_ll_set_reg0x380_dqt_table_dc(uint32_t value)
3110 {
3111 REG_WRITE(JPEG_DEC_REG0X380_ADDR,value);
3112 }
3113
3114 /* REG_0x3C0 */
3115 #define JPEG_DEC_REG0X3C0_ADDR (JPEG_DEC_LL_REG_BASE + 0x3C0*4) //REG ADDR :0x48040f00
3116 #define JPEG_DEC_REG0X3C0_DQT_TABLE_AC_POS (0)
3117 #define JPEG_DEC_REG0X3C0_DQT_TABLE_AC_MASK (0xFFFFFFFF)
3118
jpeg_dec_ll_get_reg0x3c0_value(void)3119 static inline uint32_t jpeg_dec_ll_get_reg0x3c0_value(void)
3120 {
3121 return REG_READ(JPEG_DEC_REG0X3C0_ADDR);
3122 }
3123
jpeg_dec_ll_set_reg0x3c0_value(uint32_t value)3124 static inline void jpeg_dec_ll_set_reg0x3c0_value(uint32_t value)
3125 {
3126 REG_WRITE(JPEG_DEC_REG0X3C0_ADDR,value);
3127 }
3128
3129 /* REG_0x3c0:reg0x3c0->DQT_table_ac:0x3c0,DQT_table_ac,0x0,R/W*/
jpeg_dec_ll_get_reg0x3c0_dqt_table_ac(void)3130 static inline uint32_t jpeg_dec_ll_get_reg0x3c0_dqt_table_ac(void)
3131 {
3132 return REG_READ(JPEG_DEC_REG0X3C0_ADDR);
3133 }
3134
jpeg_dec_ll_set_reg0x3c0_dqt_table_ac(uint32_t value)3135 static inline void jpeg_dec_ll_set_reg0x3c0_dqt_table_ac(uint32_t value)
3136 {
3137 REG_WRITE(JPEG_DEC_REG0X3C0_ADDR,value);
3138 }
3139
3140 #ifdef __cplusplus
3141 }
3142 #endif
3143