1 /*---------------------------------------------------------------------------*
2 Project: TwlSDK - G2 -
3 File: gx_bgcnt.h
4
5 Copyright 2003-2008 Nintendo. All rights reserved.
6
7 These coded instructions, statements, and computer programs contain
8 proprietary information of Nintendo of America Inc. and/or Nintendo
9 Company Ltd., and are protected by Federal copyright law. They may
10 not be disclosed to third parties or copied or duplicated in any form,
11 in whole or in part, without the prior written consent of Nintendo.
12
13 $Date:: 2008-09-18#$
14 $Rev: 8573 $
15 $Author: okubata_ryoma $
16 *---------------------------------------------------------------------------*/
17
18 #ifndef NITRO_GX_BGCNT_H_
19 #define NITRO_GX_BGCNT_H_
20
21 #include <nitro/gx/gxcommon.h>
22 #ifdef SDK_NITRO
23 #include <nitro/hw/ARM9/ioreg_GX.h>
24 #include <nitro/hw/ARM9/ioreg_G2.h>
25 #include <nitro/hw/ARM9/ioreg_GXS.h>
26 #include <nitro/hw/ARM9/ioreg_G2S.h>
27 #else
28 #include <twl/hw/ARM9/ioreg_GX.h>
29 #include <twl/hw/ARM9/ioreg_G2.h>
30 #include <twl/hw/ARM9/ioreg_GXS.h>
31 #include <twl/hw/ARM9/ioreg_G2S.h>
32 #endif
33
34 #ifdef __cplusplus
35 extern "C" {
36 #endif
37
38 //----------------------------------------------------------------------------
39 // Type definition
40 //----------------------------------------------------------------------------
41
42 typedef union
43 {
44 u16 raw;
45 struct
46 {
47 u16 priority:2;
48 u16 charBase:4;
49 u16 mosaic:1;
50 u16 colorMode:1;
51 u16 screenBase:5;
52 u16 bgExtPltt:1;
53 u16 screenSize:2;
54 };
55 }
56 GXBg01Control;
57
58 typedef union
59 {
60 u16 raw;
61 struct
62 {
63 u16 priority:2;
64 u16 charBase:4;
65 u16 mosaic:1;
66 u16 colorMode:1;
67 u16 screenBase:5;
68 u16 _reserve:1;
69 u16 screenSize:2;
70 };
71 }
72 GXBg23ControlText;
73
74 typedef union
75 {
76 u16 raw;
77 struct
78 {
79 u16 priority:2;
80 u16 charBase:4;
81 u16 mosaic:1;
82 u16 _reserve:1;
83 u16 screenBase:5;
84 u16 areaOver:1;
85 u16 screenSize:2;
86 };
87 }
88 GXBg23ControlAffine;
89
90 typedef union
91 {
92 u16 raw;
93 struct
94 {
95 u16 priority:2;
96 u16 _reserve1:1;
97 u16 charBase:3;
98 u16 mosaic:1;
99 u16 _reserve2:1;
100 u16 screenBase:5;
101 u16 areaOver:1;
102 u16 screenSize:2;
103 };
104 }
105 GXBg23Control256x16Pltt;
106
107 typedef union
108 {
109 u16 raw;
110 struct
111 {
112 u16 priority:2;
113 u16 charBase:4;
114 u16 mosaic:1;
115 u16 _reserve:1;
116 u16 screenBase:5;
117 u16 areaOver:1;
118 u16 screenSize:2;
119 };
120 }
121 GXBg23Control256x16Affine;
122
123
124 typedef union
125 {
126 u16 raw;
127 struct
128 {
129 u16 priority:2;
130 u16 _reserve1:4;
131 u16 mosaic:1;
132 u16 _reserve2:1;
133 u16 screenBase:5;
134 u16 areaOver:1;
135 u16 screenSize:2;
136 };
137 }
138 GXBg23Control256Bmp, GXBg23ControlDCBmp;
139
140 typedef union
141 {
142 u16 raw;
143 struct
144 {
145 u16 priority:2;
146 u16 _reserve1:4;
147 u16 mosaic:1;
148 u16 _reserve2:6;
149 u16 areaOver:1;
150 u16 screenSize:2;
151 };
152 }
153 GXBg2ControlLargeBmp;
154
155
156
157 typedef enum
158 {
159 GX_BG_SCRSIZE_TEXT_256x256 = 0,
160 GX_BG_SCRSIZE_TEXT_512x256 = 1,
161 GX_BG_SCRSIZE_TEXT_256x512 = 2,
162 GX_BG_SCRSIZE_TEXT_512x512 = 3
163 }
164 GXBGScrSizeText;
165
166 #define GX_BG_SCRSIZE_TEXT_ASSERT(x) \
167 SDK_MINMAX_ASSERT(x, GX_BG_SCRSIZE_TEXT_256x256, GX_BG_SCRSIZE_TEXT_512x512)
168
169 typedef enum
170 {
171 GX_BG_SCRSIZE_AFFINE_128x128 = 0,
172 GX_BG_SCRSIZE_AFFINE_256x256 = 1,
173 GX_BG_SCRSIZE_AFFINE_512x512 = 2,
174 GX_BG_SCRSIZE_AFFINE_1024x1024 = 3
175 }
176 GXBGScrSizeAffine;
177
178 #define GX_BG_SCRSIZE_AFFINE_ASSERT(x) \
179 SDK_MINMAX_ASSERT(x, GX_BG_SCRSIZE_AFFINE_128x128, GX_BG_SCRSIZE_AFFINE_1024x1024)
180
181 typedef enum
182 {
183 GX_BG_SCRSIZE_256x16PLTT_128x128 = 0,
184 GX_BG_SCRSIZE_256x16PLTT_256x256 = 1,
185 GX_BG_SCRSIZE_256x16PLTT_512x512 = 2,
186 GX_BG_SCRSIZE_256x16PLTT_1024x1024 = 3
187 }
188 GXBGScrSize256x16Pltt;
189
190 #define GX_BG_SCRSIZE_256x16PLTT_ASSERT(x) \
191 SDK_MINMAX_ASSERT(x, GX_BG_SCRSIZE_256x16PLTT_128x128, GX_BG_SCRSIZE_256x16PLTT_1024x1024)
192
193 typedef enum
194 {
195 GX_BG_SCRSIZE_256BMP_128x128 = 0,
196 GX_BG_SCRSIZE_256BMP_256x256 = 1,
197 GX_BG_SCRSIZE_256BMP_512x256 = 2,
198 GX_BG_SCRSIZE_256BMP_512x512 = 3
199 }
200 GXBGScrSize256Bmp;
201
202 #define GX_BG_SCRSIZE_256BMP_ASSERT(x) \
203 SDK_MINMAX_ASSERT(x, GX_BG_SCRSIZE_256BMP_128x128, GX_BG_SCRSIZE_256BMP_512x512)
204
205 typedef enum
206 {
207 GX_BG_SCRSIZE_DCBMP_128x128 = 0,
208 GX_BG_SCRSIZE_DCBMP_256x256 = 1,
209 GX_BG_SCRSIZE_DCBMP_512x256 = 2,
210 GX_BG_SCRSIZE_DCBMP_512x512 = 3
211 }
212 GXBGScrSizeDcBmp;
213
214 #define GX_BG_SCRSIZE_DCBMP_ASSERT(x) \
215 SDK_MINMAX_ASSERT(x, GX_BG_SCRSIZE_DCBMP_128x128, GX_BG_SCRSIZE_DCBMP_512x512)
216
217 typedef enum
218 {
219 GX_BG_SCRSIZE_LARGEBMP_512x1024 = 0,
220 GX_BG_SCRSIZE_LARGEBMP_1024x512 = 1
221 }
222 GXBGScrSizeLargeBmp;
223
224 #define GX_BG_SCRSIZE_LARGEBMP_ASSERT(x) \
225 SDK_MINMAX_ASSERT(x, GX_BG_SCRSIZE_LARGEBMP_512x1024, GX_BG_SCRSIZE_LARGEBMP_1024x512)
226
227 typedef enum
228 {
229 GX_BG_COLORMODE_16 = 0,
230 GX_BG_COLORMODE_256 = 1
231 }
232 GXBGColorMode;
233
234 #define GX_BG_COLORMODE_ASSERT(x) \
235 SDK_MINMAX_ASSERT(x, GX_BG_COLORMODE_16, GX_BG_COLORMODE_256)
236
237
238 typedef enum
239 {
240 GX_BG_AREAOVER_XLU = 0,
241 GX_BG_AREAOVER_REPEAT = 1
242 }
243 GXBGAreaOver;
244
245 #define GX_BG_AREAOVER_ASSERT(x) \
246 SDK_MINMAX_ASSERT(x, GX_BG_AREAOVER_XLU, GX_BG_AREAOVER_REPEAT)
247
248 typedef enum
249 {
250 GX_BG_CHARBASE_0x00000 = 0,
251 GX_BG_CHARBASE_0x04000 = 1,
252 GX_BG_CHARBASE_0x08000 = 2,
253 GX_BG_CHARBASE_0x0c000 = 3,
254 GX_BG_CHARBASE_0x10000 = 4,
255 GX_BG_CHARBASE_0x14000 = 5,
256 GX_BG_CHARBASE_0x18000 = 6,
257 GX_BG_CHARBASE_0x1c000 = 7,
258 GX_BG_CHARBASE_0x20000 = 8,
259 GX_BG_CHARBASE_0x24000 = 9,
260 GX_BG_CHARBASE_0x28000 = 10,
261 GX_BG_CHARBASE_0x2c000 = 11,
262 GX_BG_CHARBASE_0x30000 = 12,
263 GX_BG_CHARBASE_0x34000 = 13,
264 GX_BG_CHARBASE_0x38000 = 14,
265 GX_BG_CHARBASE_0x3c000 = 15
266 }
267 GXBGCharBase;
268
269 #define GX_BG_CHARBASE_ASSERT(x) \
270 SDK_MINMAX_ASSERT(x, GX_BG_CHARBASE_0x00000, GX_BG_CHARBASE_0x3c000)
271
272 typedef enum
273 {
274 GX_BG_SCRBASE_0x0000 = 0,
275 GX_BG_SCRBASE_0x0800 = 1,
276 GX_BG_SCRBASE_0x1000 = 2,
277 GX_BG_SCRBASE_0x1800 = 3,
278 GX_BG_SCRBASE_0x2000 = 4,
279 GX_BG_SCRBASE_0x2800 = 5,
280 GX_BG_SCRBASE_0x3000 = 6,
281 GX_BG_SCRBASE_0x3800 = 7,
282 GX_BG_SCRBASE_0x4000 = 8,
283 GX_BG_SCRBASE_0x4800 = 9,
284 GX_BG_SCRBASE_0x5000 = 10,
285 GX_BG_SCRBASE_0x5800 = 11,
286 GX_BG_SCRBASE_0x6000 = 12,
287 GX_BG_SCRBASE_0x6800 = 13,
288 GX_BG_SCRBASE_0x7000 = 14,
289 GX_BG_SCRBASE_0x7800 = 15,
290 GX_BG_SCRBASE_0x8000 = 16,
291 GX_BG_SCRBASE_0x8800 = 17,
292 GX_BG_SCRBASE_0x9000 = 18,
293 GX_BG_SCRBASE_0x9800 = 19,
294 GX_BG_SCRBASE_0xa000 = 20,
295 GX_BG_SCRBASE_0xa800 = 21,
296 GX_BG_SCRBASE_0xb000 = 22,
297 GX_BG_SCRBASE_0xb800 = 23,
298 GX_BG_SCRBASE_0xc000 = 24,
299 GX_BG_SCRBASE_0xc800 = 25,
300 GX_BG_SCRBASE_0xd000 = 26,
301 GX_BG_SCRBASE_0xd800 = 27,
302 GX_BG_SCRBASE_0xe000 = 28,
303 GX_BG_SCRBASE_0xe800 = 29,
304 GX_BG_SCRBASE_0xf000 = 30,
305 GX_BG_SCRBASE_0xf800 = 31
306 }
307 GXBGScrBase;
308
309 #define GX_BG_SCRBASE_ASSERT(x) \
310 SDK_MINMAX_ASSERT(x, GX_BG_SCRBASE_0x0000, GX_BG_SCRBASE_0xf800)
311
312 typedef enum
313 {
314 GX_BG_BMPSCRBASE_0x00000 = 0,
315 GX_BG_BMPSCRBASE_0x04000 = 1,
316 GX_BG_BMPSCRBASE_0x08000 = 2,
317 GX_BG_BMPSCRBASE_0x0c000 = 3,
318 GX_BG_BMPSCRBASE_0x10000 = 4,
319 GX_BG_BMPSCRBASE_0x14000 = 5,
320 GX_BG_BMPSCRBASE_0x18000 = 6,
321 GX_BG_BMPSCRBASE_0x1c000 = 7,
322 GX_BG_BMPSCRBASE_0x20000 = 8,
323 GX_BG_BMPSCRBASE_0x24000 = 9,
324 GX_BG_BMPSCRBASE_0x28000 = 10,
325 GX_BG_BMPSCRBASE_0x2c000 = 11,
326 GX_BG_BMPSCRBASE_0x30000 = 12,
327 GX_BG_BMPSCRBASE_0x34000 = 13,
328 GX_BG_BMPSCRBASE_0x38000 = 14,
329 GX_BG_BMPSCRBASE_0x3c000 = 15,
330 GX_BG_BMPSCRBASE_0x40000 = 16,
331 GX_BG_BMPSCRBASE_0x44000 = 17,
332 GX_BG_BMPSCRBASE_0x48000 = 18,
333 GX_BG_BMPSCRBASE_0x4c000 = 19,
334 GX_BG_BMPSCRBASE_0x50000 = 20,
335 GX_BG_BMPSCRBASE_0x54000 = 21,
336 GX_BG_BMPSCRBASE_0x58000 = 22,
337 GX_BG_BMPSCRBASE_0x5c000 = 23,
338 GX_BG_BMPSCRBASE_0x60000 = 24,
339 GX_BG_BMPSCRBASE_0x64000 = 25,
340 GX_BG_BMPSCRBASE_0x68000 = 26,
341 GX_BG_BMPSCRBASE_0x6c000 = 27,
342 GX_BG_BMPSCRBASE_0x70000 = 28,
343 GX_BG_BMPSCRBASE_0x74000 = 29,
344 GX_BG_BMPSCRBASE_0x78000 = 30,
345 GX_BG_BMPSCRBASE_0x7c000 = 31
346 }
347 GXBGBmpScrBase;
348
349 #define GX_BG_BMPSCRBASE_ASSERT(x) \
350 SDK_MINMAX_ASSERT(x, GX_BG_BMPSCRBASE_0x00000, GX_BG_BMPSCRBASE_0x7c000)
351
352 typedef enum
353 {
354 GX_BG_EXTPLTT_01 = 0,
355 GX_BG_EXTPLTT_23 = 1
356 }
357 GXBGExtPltt;
358
359 #define GX_BG_EXTPLTT_ASSERT(x) \
360 SDK_MINMAX_ASSERT(x, GX_BG_EXTPLTT_01, GX_BG_EXTPLTT_23)
361
362 #define GX_BG_PRIORITY_ASSERT(x) SDK_MINMAX_ASSERT(x, 0, 3)
363
364
365 typedef enum
366 {
367 GX_BG_EXTMODE_256x16PLTT =
368 (0 << REG_G2_BG2CNT_CHARBASE_SHIFT) | (0 << REG_G2_BG2CNT_COLORMODE_SHIFT),
369 GX_BG_EXTMODE_256BITMAP =
370 (0 << REG_G2_BG2CNT_CHARBASE_SHIFT) | (1 << REG_G2_BG2CNT_COLORMODE_SHIFT),
371 GX_BG_EXTMODE_DCBITMAP =
372 (1 << REG_G2_BG2CNT_CHARBASE_SHIFT) | (1 << REG_G2_BG2CNT_COLORMODE_SHIFT)
373 }
374 GXBGExtMode;
375
376
377 /* if include from Other Environment for exsample VC or BCB, */
378 /* please define SDK_FROM_TOOL */
379 #if !(defined(SDK_WIN32) || defined(SDK_FROM_TOOL))
380
381 //----------------------------------------------------------------------------
382 // Declaration of function
383 //----------------------------------------------------------------------------
384
385 //
386 // Main 2D engine
387 //
388
389 // BG0CNT
390 static void G2_SetBG0Control(GXBGScrSizeText screenSize,
391 GXBGColorMode colorMode,
392 GXBGScrBase screenBase, GXBGCharBase charBase, GXBGExtPltt bgExtPltt);
393
394 // BG1CNT
395 static void G2_SetBG1Control(GXBGScrSizeText screenSize,
396 GXBGColorMode colorMode,
397 GXBGScrBase screenBase, GXBGCharBase charBase, GXBGExtPltt bgExtPltt);
398
399 // BG2CNT
400 static void G2_SetBG2ControlText(GXBGScrSizeText screenSize,
401 GXBGColorMode colorMode,
402 GXBGScrBase screenBase, GXBGCharBase charBase);
403
404 static void G2_SetBG2ControlAffine(GXBGScrSizeAffine screenSize,
405 GXBGAreaOver areaOver,
406 GXBGScrBase screenBase, GXBGCharBase charBase);
407
408 #define G2_SetBG2Control256x16Pltt G2_SetBG2Control256x16Affine
409 static void G2_SetBG2Control256x16Affine(GXBGScrSize256x16Pltt screenSize,
410 GXBGAreaOver areaOver,
411 GXBGScrBase screenBase, GXBGCharBase charBase);
412
413 static void G2_SetBG2Control256Bmp(GXBGScrSize256Bmp screenSize,
414 GXBGAreaOver areaOver, GXBGBmpScrBase screenBase);
415
416 static void G2_SetBG2ControlDCBmp(GXBGScrSizeDcBmp screenSize,
417 GXBGAreaOver areaOver, GXBGBmpScrBase screenBase);
418
419 static void G2_SetBG2ControlLargeBmp(GXBGScrSizeLargeBmp screenSize, GXBGAreaOver areaOver);
420
421 // BG3CNT
422 static void G2_SetBG3ControlText(GXBGScrSizeText screenSize,
423 GXBGColorMode colorMode,
424 GXBGScrBase screenBase, GXBGCharBase charBase);
425
426 static void G2_SetBG3ControlAffine(GXBGScrSizeAffine screenSize,
427 GXBGAreaOver areaOver,
428 GXBGScrBase screenBase, GXBGCharBase charBase);
429
430 #define G2_SetBG3Control256x16Pltt G2_SetBG3Control256x16Affine
431 static void G2_SetBG3Control256x16Affine(GXBGScrSize256x16Pltt screenSize,
432 GXBGAreaOver areaOver,
433 GXBGScrBase screenBase, GXBGCharBase charBase);
434
435 static void G2_SetBG3Control256Bmp(GXBGScrSize256Bmp screenSize,
436 GXBGAreaOver areaOver, GXBGBmpScrBase screenBase);
437
438 static void G2_SetBG3ControlDCBmp(GXBGScrSizeDcBmp screenSize,
439 GXBGAreaOver areaOver, GXBGBmpScrBase screenBase);
440
441 static void G2_SetBG0Priority(int priority);
442 static void G2_SetBG1Priority(int priority);
443 static void G2_SetBG2Priority(int priority);
444 static void G2_SetBG3Priority(int priority);
445
446 static void G2_BG0Mosaic(BOOL enable);
447 static void G2_BG1Mosaic(BOOL enable);
448 static void G2_BG2Mosaic(BOOL enable);
449 static void G2_BG3Mosaic(BOOL enable);
450
451 // Utilities
452 void *G2_GetBG0ScrPtr(void);
453 void *G2_GetBG1ScrPtr(void);
454 void *G2_GetBG2ScrPtr(void);
455 void *G2_GetBG3ScrPtr(void);
456 void *G2_GetBG0CharPtr(void);
457 void *G2_GetBG1CharPtr(void);
458 void *G2_GetBG2CharPtr(void);
459 void *G2_GetBG3CharPtr(void);
460 static void *G2_GetOBJCharPtr(void); // fixed(always returns (void*)HW_OBJ_VRAM)
461
462 //
463 // Sub 2D engine
464 //
465
466 // BG0CNT
467 static void G2S_SetBG0Control(GXBGScrSizeText screenSize,
468 GXBGColorMode colorMode,
469 GXBGScrBase screenBase, GXBGCharBase charBase, GXBGExtPltt bgExtPltt);
470
471 // BG1CNT
472 static void G2S_SetBG1Control(GXBGScrSizeText screenSize,
473 GXBGColorMode colorMode,
474 GXBGScrBase screenBase, GXBGCharBase charBase, GXBGExtPltt bgExtPltt);
475
476 // BG2CNT
477 static void G2S_SetBG2ControlText(GXBGScrSizeText screenSize,
478 GXBGColorMode colorMode,
479 GXBGScrBase screenBase, GXBGCharBase charBase);
480
481 static void G2S_SetBG2ControlAffine(GXBGScrSizeAffine screenSize,
482 GXBGAreaOver areaOver,
483 GXBGScrBase screenBase, GXBGCharBase charBase);
484
485 #define G2S_SetBG2Control256x16Pltt G2S_SetBG2Control256x16Affine
486 static void G2S_SetBG2Control256x16Affine(GXBGScrSize256x16Pltt screenSize,
487 GXBGAreaOver areaOver,
488 GXBGScrBase screenBase, GXBGCharBase charBase);
489
490 static void G2S_SetBG2Control256Bmp(GXBGScrSize256Bmp screenSize,
491 GXBGAreaOver areaOver, GXBGBmpScrBase screenBase);
492
493 static void G2S_SetBG2ControlDCBmp(GXBGScrSizeDcBmp screenSize,
494 GXBGAreaOver areaOver, GXBGBmpScrBase screenBase);
495
496 // BG3CNT
497 static void G2S_SetBG3ControlText(GXBGScrSizeText screenSize,
498 GXBGColorMode colorMode,
499 GXBGScrBase screenBase, GXBGCharBase charBase);
500
501 static void G2S_SetBG3ControlAffine(GXBGScrSizeAffine screenSize,
502 GXBGAreaOver areaOver,
503 GXBGScrBase screenBase, GXBGCharBase charBase);
504
505 #define G2S_SetBG3Control256x16Pltt G2S_SetBG3Control256x16Affine
506 static void G2S_SetBG3Control256x16Affine(GXBGScrSize256x16Pltt screenSize,
507 GXBGAreaOver areaOver,
508 GXBGScrBase screenBase, GXBGCharBase charBase);
509
510 static void G2S_SetBG3Control256Bmp(GXBGScrSize256Bmp screenSize,
511 GXBGAreaOver areaOver, GXBGBmpScrBase screenBase);
512
513 static void G2S_SetBG3ControlDCBmp(GXBGScrSizeDcBmp screenSize,
514 GXBGAreaOver areaOver, GXBGBmpScrBase screenBase);
515
516 static void G2S_SetBG0Priority(int priority);
517 static void G2S_SetBG1Priority(int priority);
518 static void G2S_SetBG2Priority(int priority);
519 static void G2S_SetBG3Priority(int priority);
520
521 static void G2S_BG0Mosaic(BOOL enable);
522 static void G2S_BG1Mosaic(BOOL enable);
523 static void G2S_BG2Mosaic(BOOL enable);
524 static void G2S_BG3Mosaic(BOOL enable);
525
526
527 void *G2S_GetBG0ScrPtr(void);
528 void *G2S_GetBG1ScrPtr(void);
529 void *G2S_GetBG2ScrPtr(void);
530 void *G2S_GetBG3ScrPtr(void);
531 void *G2S_GetBG0CharPtr(void);
532 void *G2S_GetBG1CharPtr(void);
533 void *G2S_GetBG2CharPtr(void);
534 void *G2S_GetBG3CharPtr(void);
535 static void *G2S_GetOBJCharPtr(void); // fixed(always returns (void*)HW_DB_OBJ_VRAM)
536
537
538 //----------------------------------------------------------------------------
539 // Implementation of inline function
540 //----------------------------------------------------------------------------
541
542 #define GX_BG0_2D_CHECK_WARNING \
543 SDK_WARNING(!(reg_GX_DISPCNT & REG_GX_DISPCNT_BG02D3D_MASK), \
544 "G2_SetBG0Control: BG #0 assigned to 3D now.")
545 #ifdef SDK_DEBUG
546 #define GX_BGMODE_WARNING1(name, mode1) \
547 do { \
548 u32 tmp = (reg_GX_DISPCNT & REG_GX_DISPCNT_BGMODE_MASK) >> REG_GX_DISPCNT_BGMODE_SHIFT; \
549 SDK_WARNING(tmp == mode1, \
550 #name ## ": BG mode should be %d", mode1); \
551 (void)0; \
552 } while(0)
553
554 #define GX_BGMODE_WARNING2(name, mode1, mode2) \
555 do { \
556 u32 tmp = (reg_GX_DISPCNT & REG_GX_DISPCNT_BGMODE_MASK) >> REG_GX_DISPCNT_BGMODE_SHIFT; \
557 SDK_WARNING(tmp == mode1 || tmp == mode2, \
558 #name ## ": BG mode should be %d or %d", mode1, mode2); \
559 (void)0; \
560 } while(0)
561
562 #define GX_BGMODE_WARNING3(name, mode1, mode2, mode3) \
563 do { \
564 u32 tmp = (reg_GX_DISPCNT & REG_GX_DISPCNT_BGMODE_MASK) >> REG_GX_DISPCNT_BGMODE_SHIFT; \
565 SDK_WARNING(tmp == mode1 || tmp == mode2 || tmp == mode3, \
566 #name ## ": BG mode should be %d, %d, or %d", mode1, mode2, mode3); \
567 (void)0; \
568 } while(0)
569
570 #define GXS_BGMODE_WARNING1(name, mode1) \
571 do { \
572 u32 tmp = (reg_GXS_DB_DISPCNT & REG_GXS_DB_DISPCNT_BGMODE_MASK) >> REG_GXS_DB_DISPCNT_BGMODE_SHIFT; \
573 SDK_WARNING(tmp == mode1, \
574 #name ## ": BG mode should be %d", mode1); \
575 (void)0; \
576 } while(0)
577
578 #define GXS_BGMODE_WARNING2(name, mode1, mode2) \
579 do { \
580 u32 tmp = (reg_GXS_DB_DISPCNT & REG_GXS_DB_DISPCNT_BGMODE_MASK) >> REG_GXS_DB_DISPCNT_BGMODE_SHIFT; \
581 SDK_WARNING(tmp == mode1 || tmp == mode2, \
582 #name ## ": BG mode should be %d or %d", mode1, mode2); \
583 (void)0; \
584 } while(0)
585
586 #define GXS_BGMODE_WARNING3(name, mode1, mode2, mode3) \
587 do { \
588 u32 tmp = (reg_GXS_DB_DISPCNT & REG_GXS_DB_DISPCNT_BGMODE_MASK) >> REG_GXS_DB_DISPCNT_BGMODE_SHIFT; \
589 SDK_WARNING(tmp == mode1 || tmp == mode2 || tmp == mode3, \
590 #name ## ": BG mode should be %d, %d, or %d", mode1, mode2, mode3); \
591 (void)0; \
592 } while(0)
593
594 #else
595 #define GX_BGMODE_WARNING1(name, mode1) ((void) 0)
596 #define GX_BGMODE_WARNING2(name, mode1, mode2) ((void) 0)
597 #define GX_BGMODE_WARNING3(name, mode1, mode2, mode3) ((void) 0)
598 #define GXS_BGMODE_WARNING1(name, mode1) ((void) 0)
599 #define GXS_BGMODE_WARNING2(name, mode1, mode2) ((void) 0)
600 #define GXS_BGMODE_WARNING3(name, mode1, mode2, mode3) ((void) 0)
601 #endif
602
603 /*---------------------------------------------------------------------------*
604 Name: G2_SetBG0Control
605
606 Description: Sets up BG #0(MAIN engine)
607
608 Arguments: screenSize screen size
609 colorMode color mode
610 screenBase screen base
611 charBase character base
612 bgExtPltt ext. palette select
613
614 Returns: none
615 *---------------------------------------------------------------------------*/
G2_SetBG0Control(GXBGScrSizeText screenSize,GXBGColorMode colorMode,GXBGScrBase screenBase,GXBGCharBase charBase,GXBGExtPltt bgExtPltt)616 static inline void G2_SetBG0Control(GXBGScrSizeText screenSize,
617 GXBGColorMode colorMode,
618 GXBGScrBase screenBase,
619 GXBGCharBase charBase, GXBGExtPltt bgExtPltt)
620 {
621 GX_BG_SCRSIZE_TEXT_ASSERT(screenSize);
622 GX_BG_COLORMODE_ASSERT(colorMode);
623 GX_BG_SCRBASE_ASSERT(screenBase);
624 GX_BG_CHARBASE_ASSERT(charBase);
625 GX_BG_EXTPLTT_ASSERT(bgExtPltt);
626 GX_BG0_2D_CHECK_WARNING;
627
628 reg_G2_BG0CNT =
629 (u16)((reg_G2_BG0CNT & (REG_G2_BG0CNT_PRIORITY_MASK | REG_G2_BG0CNT_MOSAIC_MASK)) |
630 (screenSize << REG_G2_BG0CNT_SCREENSIZE_SHIFT) | (colorMode <<
631 REG_G2_BG0CNT_COLORMODE_SHIFT) |
632 (screenBase << REG_G2_BG0CNT_SCREENBASE_SHIFT) | (charBase <<
633 REG_G2_BG0CNT_CHARBASE_SHIFT) |
634 (bgExtPltt << REG_G2_BG0CNT_BGPLTTSLOT_SHIFT));
635 }
636
637
638 /*---------------------------------------------------------------------------*
639 Name: G2_GetBG0Control
640
641 Description: Get BG #0 Control State(MAIN engine)
642
643 Arguments: BG Control structure.
644
645 Returns: none
646 *---------------------------------------------------------------------------*/
G2_GetBG0Control(void)647 static inline GXBg01Control G2_GetBG0Control(void)
648 {
649 GX_BG0_2D_CHECK_WARNING;
650
651 return *(volatile GXBg01Control *)REG_BG0CNT_ADDR;
652 }
653
654
655 /*---------------------------------------------------------------------------*
656 Name: G2S_SetBG0Control
657
658 Description: Sets up BG #0(SUB engine)
659
660 Arguments: screenSize screen size
661 colorMode color mode
662 screenBase screen base
663 charBase character base
664 bgExtPltt ext. palette select
665
666 Returns: none
667 *---------------------------------------------------------------------------*/
G2S_SetBG0Control(GXBGScrSizeText screenSize,GXBGColorMode colorMode,GXBGScrBase screenBase,GXBGCharBase charBase,GXBGExtPltt bgExtPltt)668 static inline void G2S_SetBG0Control(GXBGScrSizeText screenSize,
669 GXBGColorMode colorMode,
670 GXBGScrBase screenBase,
671 GXBGCharBase charBase, GXBGExtPltt bgExtPltt)
672 {
673 GX_BG_SCRSIZE_TEXT_ASSERT(screenSize);
674 GX_BG_COLORMODE_ASSERT(colorMode);
675 GX_BG_SCRBASE_ASSERT(screenBase);
676 GX_BG_CHARBASE_ASSERT(charBase);
677 GX_BG_EXTPLTT_ASSERT(bgExtPltt);
678
679 reg_G2S_DB_BG0CNT =
680 (u16)((reg_G2S_DB_BG0CNT &
681 (REG_G2S_DB_BG0CNT_PRIORITY_MASK | REG_G2S_DB_BG0CNT_MOSAIC_MASK)) | (screenSize <<
682 REG_G2S_DB_BG0CNT_SCREENSIZE_SHIFT)
683 | (colorMode << REG_G2S_DB_BG0CNT_COLORMODE_SHIFT) | (screenBase <<
684 REG_G2S_DB_BG0CNT_SCREENBASE_SHIFT)
685 | (charBase << REG_G2S_DB_BG0CNT_CHARBASE_SHIFT) | (bgExtPltt <<
686 REG_G2S_DB_BG0CNT_BGPLTTSLOT_SHIFT));
687 }
688
689 /*---------------------------------------------------------------------------*
690 Name: G2S_GetBG0Control
691
692 Description: Get BG #0 Control State(SUB engine)
693
694 Arguments: BG Control structure.
695
696 Returns: none
697 *---------------------------------------------------------------------------*/
G2S_GetBG0Control(void)698 static inline GXBg01Control G2S_GetBG0Control(void)
699 {
700 return *(volatile GXBg01Control *)REG_DB_BG0CNT_ADDR;
701 }
702
703
704 /*---------------------------------------------------------------------------*
705 Name: G2_SetBG1Control
706
707 Description: Sets up BG #1(MAIN engine).
708
709 Arguments: screenSize screen size
710 colorMode color mode
711 screenBase screen base
712 charBase character base
713 bgExtPltt ext. palette select
714
715 Returns: none
716 *---------------------------------------------------------------------------*/
G2_SetBG1Control(GXBGScrSizeText screenSize,GXBGColorMode colorMode,GXBGScrBase screenBase,GXBGCharBase charBase,GXBGExtPltt bgExtPltt)717 static inline void G2_SetBG1Control(GXBGScrSizeText screenSize,
718 GXBGColorMode colorMode,
719 GXBGScrBase screenBase,
720 GXBGCharBase charBase, GXBGExtPltt bgExtPltt)
721 {
722 GX_BG_SCRSIZE_TEXT_ASSERT(screenSize);
723 GX_BG_COLORMODE_ASSERT(colorMode);
724 GX_BG_SCRBASE_ASSERT(screenBase);
725 GX_BG_CHARBASE_ASSERT(charBase);
726 GX_BG_EXTPLTT_ASSERT(bgExtPltt);
727
728 reg_G2_BG1CNT =
729 (u16)((reg_G2_BG1CNT & (REG_G2_BG1CNT_PRIORITY_MASK | REG_G2_BG1CNT_MOSAIC_MASK)) |
730 (screenSize << REG_G2_BG1CNT_SCREENSIZE_SHIFT) | (colorMode <<
731 REG_G2_BG1CNT_COLORMODE_SHIFT) |
732 (screenBase << REG_G2_BG1CNT_SCREENBASE_SHIFT) | (charBase <<
733 REG_G2_BG1CNT_CHARBASE_SHIFT) |
734 (bgExtPltt << REG_G2_BG1CNT_BGPLTTSLOT_SHIFT));
735 }
736
737
738 /*---------------------------------------------------------------------------*
739 Name: G2_GetBG1Control
740
741 Description: Get BG #1 Control State(MAIN engine)
742
743 Arguments: BG Control structure.
744
745 Returns: none
746 *---------------------------------------------------------------------------*/
G2_GetBG1Control(void)747 static inline GXBg01Control G2_GetBG1Control(void)
748 {
749 return *(volatile GXBg01Control *)REG_BG1CNT_ADDR;
750 }
751
752
753 /*---------------------------------------------------------------------------*
754 Name: G2S_SetBG1Control
755
756 Description: Sets up BG #1(SUB engine).
757
758 Arguments: screenSize screen size
759 colorMode color mode
760 screenBase screen base
761 charBase character base
762 bgExtPltt ext. palette select
763
764 Returns: none
765 *---------------------------------------------------------------------------*/
G2S_SetBG1Control(GXBGScrSizeText screenSize,GXBGColorMode colorMode,GXBGScrBase screenBase,GXBGCharBase charBase,GXBGExtPltt bgExtPltt)766 static inline void G2S_SetBG1Control(GXBGScrSizeText screenSize,
767 GXBGColorMode colorMode,
768 GXBGScrBase screenBase,
769 GXBGCharBase charBase, GXBGExtPltt bgExtPltt)
770 {
771 GX_BG_SCRSIZE_TEXT_ASSERT(screenSize);
772 GX_BG_COLORMODE_ASSERT(colorMode);
773 GX_BG_SCRBASE_ASSERT(screenBase);
774 GX_BG_CHARBASE_ASSERT(charBase);
775 GX_BG_EXTPLTT_ASSERT(bgExtPltt);
776
777 reg_G2S_DB_BG1CNT =
778 (u16)((reg_G2S_DB_BG1CNT &
779 (REG_G2S_DB_BG1CNT_PRIORITY_MASK | REG_G2S_DB_BG1CNT_MOSAIC_MASK)) | (screenSize <<
780 REG_G2S_DB_BG1CNT_SCREENSIZE_SHIFT)
781 | (colorMode << REG_G2S_DB_BG1CNT_COLORMODE_SHIFT) | (screenBase <<
782 REG_G2S_DB_BG1CNT_SCREENBASE_SHIFT)
783 | (charBase << REG_G2S_DB_BG1CNT_CHARBASE_SHIFT) | (bgExtPltt <<
784 REG_G2S_DB_BG1CNT_BGPLTTSLOT_SHIFT));
785 }
786
787
788 /*---------------------------------------------------------------------------*
789 Name: G2S_GetBG1Control
790
791 Description: Get BG #1 Control State(SUB engine)
792
793 Arguments: BG Control structure.
794
795 Returns: none
796 *---------------------------------------------------------------------------*/
G2S_GetBG1Control(void)797 static inline GXBg01Control G2S_GetBG1Control(void)
798 {
799 return *(volatile GXBg01Control *)REG_DB_BG1CNT_ADDR;
800 }
801
802
803 /*---------------------------------------------------------------------------*
804 Name: G2_GetBG2ExtMode
805
806 Description: Get BG #2 Affine Ex mode(MAIN engine)
807
808 Arguments: none.
809
810 Returns: Affine Ex mode
811 *---------------------------------------------------------------------------*/
G2_GetBG2ExtMode(void)812 static inline GXBGExtMode G2_GetBG2ExtMode(void)
813 {
814 GX_BGMODE_WARNING1(G2_GetBG2ExtMode, 5);
815
816 //return (GXBGExtMode)(reg_G2_BG2CNT &
817 // ((1 << REG_G2_BG2CNT_CHARBASE_SHIFT) | REG_G2_BG2CNT_COLORMODE_MASK));
818 return (GXBGExtMode)(reg_G2_BG2CNT &
819 (((reg_G2_BG2CNT & REG_G2_BG2CNT_COLORMODE_MASK) >> 5) |
820 REG_G2_BG2CNT_COLORMODE_MASK));
821 }
822
823 /*---------------------------------------------------------------------------*
824 Name: G2S_GetBG2ExtMode
825
826 Description: Get BG #2 Affine Ex mode(SUB engine)
827
828 Arguments: none.
829
830 Returns: Affine Ex mode
831 *---------------------------------------------------------------------------*/
G2S_GetBG2ExtMode(void)832 static inline GXBGExtMode G2S_GetBG2ExtMode(void)
833 {
834 GXS_BGMODE_WARNING1(G2S_GetBG2ExtMode, 5);
835
836 //return (GXBGExtMode)(reg_G2S_DB_BG2CNT &
837 // ((1 << REG_G2_BG2CNT_CHARBASE_SHIFT) | REG_G2_BG2CNT_COLORMODE_MASK));
838 return (GXBGExtMode)(reg_G2S_DB_BG2CNT &
839 (((reg_G2S_DB_BG2CNT & REG_G2S_DB_BG2CNT_COLORMODE_MASK) >> 5) |
840 REG_G2S_DB_BG2CNT_COLORMODE_MASK));
841 }
842
843
844 /*---------------------------------------------------------------------------*
845 Name: G2_SetBG2ControlText
846
847 Description: Sets up BG #2 as a text BG(MAIN engine).
848
849 Arguments: screenSize screen size
850 colorMode color mode
851 screenBase screen base
852 charBase character base
853
854 Returns: none
855 *---------------------------------------------------------------------------*/
G2_SetBG2ControlText(GXBGScrSizeText screenSize,GXBGColorMode colorMode,GXBGScrBase screenBase,GXBGCharBase charBase)856 static inline void G2_SetBG2ControlText(GXBGScrSizeText screenSize,
857 GXBGColorMode colorMode,
858 GXBGScrBase screenBase, GXBGCharBase charBase)
859 {
860 GX_BG_SCRSIZE_TEXT_ASSERT(screenSize);
861 GX_BG_COLORMODE_ASSERT(colorMode);
862 GX_BG_SCRBASE_ASSERT(screenBase);
863 GX_BG_CHARBASE_ASSERT(charBase);
864 GX_BGMODE_WARNING3(G2_SetBG2ControlText, 0, 1, 3);
865
866 reg_G2_BG2CNT =
867 (u16)((reg_G2_BG2CNT & (REG_G2_BG2CNT_PRIORITY_MASK | REG_G2_BG2CNT_MOSAIC_MASK)) |
868 (screenSize << REG_G2_BG2CNT_SCREENSIZE_SHIFT) | (colorMode <<
869 REG_G2_BG2CNT_COLORMODE_SHIFT) |
870 (screenBase << REG_G2_BG2CNT_SCREENBASE_SHIFT) | (charBase <<
871 REG_G2_BG2CNT_CHARBASE_SHIFT));
872 }
873
874
875 /*---------------------------------------------------------------------------*
876 Name: G2_GetBG2ControlText
877
878 Description: Get BG #2 Control State(MAIN engine)
879
880 Arguments: BG Control structure.
881
882 Returns: none
883 *---------------------------------------------------------------------------*/
G2_GetBG2ControlText(void)884 static inline GXBg23ControlText G2_GetBG2ControlText(void)
885 {
886 GX_BGMODE_WARNING3(G2_GetBG2ControlText, 0, 1, 3);
887
888 return *(volatile GXBg23ControlText *)REG_BG2CNT_ADDR;
889 }
890
891
892 /*---------------------------------------------------------------------------*
893 Name: G2S_SetBG2ControlText
894
895 Description: Sets up BG #2 as a text BG(SUB engine).
896
897 Arguments: screenSize screen size
898 colorMode color mode
899 screenBase screen base
900 charBase character base
901
902 Returns: none
903 *---------------------------------------------------------------------------*/
G2S_SetBG2ControlText(GXBGScrSizeText screenSize,GXBGColorMode colorMode,GXBGScrBase screenBase,GXBGCharBase charBase)904 static inline void G2S_SetBG2ControlText(GXBGScrSizeText screenSize,
905 GXBGColorMode colorMode,
906 GXBGScrBase screenBase, GXBGCharBase charBase)
907 {
908 GX_BG_SCRSIZE_TEXT_ASSERT(screenSize);
909 GX_BG_COLORMODE_ASSERT(colorMode);
910 GX_BG_SCRBASE_ASSERT(screenBase);
911 GX_BG_CHARBASE_ASSERT(charBase);
912 GXS_BGMODE_WARNING3(G2S_SetBG2ControlText, 0, 1, 3);
913
914 reg_G2S_DB_BG2CNT =
915 (u16)((reg_G2S_DB_BG2CNT &
916 (REG_G2S_DB_BG2CNT_PRIORITY_MASK | REG_G2S_DB_BG2CNT_MOSAIC_MASK)) | (screenSize <<
917 REG_G2S_DB_BG2CNT_SCREENSIZE_SHIFT)
918 | (colorMode << REG_G2S_DB_BG2CNT_COLORMODE_SHIFT) | (screenBase <<
919 REG_G2S_DB_BG2CNT_SCREENBASE_SHIFT)
920 | (charBase << REG_G2S_DB_BG2CNT_CHARBASE_SHIFT));
921 }
922
923
924 /*---------------------------------------------------------------------------*
925 Name: G2S_GetBG2ControlText
926
927 Description: Get BG #2 Control State(MAIN engine)
928
929 Arguments: BG Control structure.
930
931 Returns: none
932 *---------------------------------------------------------------------------*/
G2S_GetBG2ControlText(void)933 static inline GXBg23ControlText G2S_GetBG2ControlText(void)
934 {
935 GXS_BGMODE_WARNING3(G2S_GetBG2ControlText, 0, 1, 3);
936
937 return *(volatile GXBg23ControlText *)REG_DB_BG2CNT_ADDR;
938 }
939
940
941 /*---------------------------------------------------------------------------*
942 Name: G2_SetBG2ControlAffine
943
944 Description: Sets up BG #2 as an affine BG(MAIN engine).
945
946 Arguments: screenSize screen size
947 areaOver select repeat or not repeat
948 screenBase screen base block
949 charBase character base block
950
951 Returns: none
952 *---------------------------------------------------------------------------*/
G2_SetBG2ControlAffine(GXBGScrSizeAffine screenSize,GXBGAreaOver areaOver,GXBGScrBase screenBase,GXBGCharBase charBase)953 static inline void G2_SetBG2ControlAffine(GXBGScrSizeAffine screenSize,
954 GXBGAreaOver areaOver,
955 GXBGScrBase screenBase, GXBGCharBase charBase)
956 {
957 GX_BG_SCRSIZE_AFFINE_ASSERT(screenSize);
958 GX_BG_AREAOVER_ASSERT(areaOver);
959 GX_BG_SCRBASE_ASSERT(screenBase);
960 GX_BG_CHARBASE_ASSERT(charBase);
961 GX_BGMODE_WARNING2(G2_SetBG2ControlAffine, 2, 4);
962
963 reg_G2_BG2CNT =
964 (u16)((reg_G2_BG2CNT & (REG_G2_BG2CNT_PRIORITY_MASK | REG_G2_BG2CNT_MOSAIC_MASK)) |
965 (screenSize << REG_G2_BG2CNT_SCREENSIZE_SHIFT) | (screenBase <<
966 REG_G2_BG2CNT_SCREENBASE_SHIFT) |
967 (charBase << REG_G2_BG2CNT_CHARBASE_SHIFT) | (areaOver <<
968 REG_G2_BG2CNT_AREAOVER_SHIFT));
969 }
970
971
972 /*---------------------------------------------------------------------------*
973 Name: G2_GetBG2ControlAffine
974
975 Description: Get BG #2 Control State(MAIN engine)
976
977 Arguments: BG Control structure.
978
979 Returns: none
980 *---------------------------------------------------------------------------*/
G2_GetBG2ControlAffine(void)981 static inline GXBg23ControlAffine G2_GetBG2ControlAffine(void)
982 {
983 GX_BGMODE_WARNING2(G2_GetBG2ControlAffine, 2, 4);
984
985 return *(volatile GXBg23ControlAffine *)REG_BG2CNT_ADDR;
986 }
987
988
989 /*---------------------------------------------------------------------------*
990 Name: G2S_SetBG2ControlAffine
991
992 Description: Sets up BG #2 as an affine BG(SUB engine).
993
994 Arguments: screenSize screen size
995 areaOver select repeat or not repeat
996 screenBase screen base block
997 charBase character base block
998
999 Returns: none
1000 *---------------------------------------------------------------------------*/
G2S_SetBG2ControlAffine(GXBGScrSizeAffine screenSize,GXBGAreaOver areaOver,GXBGScrBase screenBase,GXBGCharBase charBase)1001 static inline void G2S_SetBG2ControlAffine(GXBGScrSizeAffine screenSize,
1002 GXBGAreaOver areaOver,
1003 GXBGScrBase screenBase, GXBGCharBase charBase)
1004 {
1005 GX_BG_SCRSIZE_AFFINE_ASSERT(screenSize);
1006 GX_BG_AREAOVER_ASSERT(areaOver);
1007 GX_BG_SCRBASE_ASSERT(screenBase);
1008 GX_BG_CHARBASE_ASSERT(charBase);
1009 GXS_BGMODE_WARNING2(G2S_SetBG2ControlAffine, 2, 4);
1010
1011 reg_G2S_DB_BG2CNT =
1012 (u16)((reg_G2S_DB_BG2CNT &
1013 (REG_G2S_DB_BG2CNT_PRIORITY_MASK | REG_G2S_DB_BG2CNT_MOSAIC_MASK)) | (screenSize <<
1014 REG_G2S_DB_BG2CNT_SCREENSIZE_SHIFT)
1015 | (screenBase << REG_G2S_DB_BG2CNT_SCREENBASE_SHIFT) | (charBase <<
1016 REG_G2S_DB_BG2CNT_CHARBASE_SHIFT)
1017 | (areaOver << REG_G2S_DB_BG2CNT_AREAOVER_SHIFT));
1018 }
1019
1020
1021 /*---------------------------------------------------------------------------*
1022 Name: G2S_GetBG2ControlAffine
1023
1024 Description: Get BG #2 Control State(SUB engine)
1025
1026 Arguments: BG Control structure.
1027
1028 Returns: none
1029 *---------------------------------------------------------------------------*/
G2S_GetBG2ControlAffine(void)1030 static inline GXBg23ControlAffine G2S_GetBG2ControlAffine(void)
1031 {
1032 GXS_BGMODE_WARNING2(G2S_GetBG2ControlAffine, 2, 4);
1033
1034 return *(volatile GXBg23ControlAffine *)REG_DB_BG2CNT_ADDR;
1035 }
1036
1037
1038 /*---------------------------------------------------------------------------*
1039 Name: G2_SetBG2Control256x16Affine
1040
1041 Description: Sets up BG #2 as an extended affine 256 colors x 16 palettes
1042 character BG(MAIN engine).
1043
1044 Arguments: screenSize screen size
1045 areaOver select repeat or not repeat
1046 screenBase screen base block
1047 charBase character base block
1048
1049 Returns: none
1050 *---------------------------------------------------------------------------*/
G2_SetBG2Control256x16Affine(GXBGScrSize256x16Pltt screenSize,GXBGAreaOver areaOver,GXBGScrBase screenBase,GXBGCharBase charBase)1051 static inline void G2_SetBG2Control256x16Affine(GXBGScrSize256x16Pltt screenSize,
1052 GXBGAreaOver areaOver,
1053 GXBGScrBase screenBase, GXBGCharBase charBase)
1054 {
1055 GX_BG_SCRSIZE_256x16PLTT_ASSERT(screenSize);
1056 GX_BG_AREAOVER_ASSERT(areaOver);
1057 GX_BG_SCRBASE_ASSERT(screenBase);
1058 GX_BG_CHARBASE_ASSERT(charBase);
1059 GX_BGMODE_WARNING1(G2_SetBG2Control256x16Affine, 5);
1060
1061 reg_G2_BG2CNT =
1062 (u16)((reg_G2_BG2CNT & (REG_G2_BG2CNT_PRIORITY_MASK | REG_G2_BG2CNT_MOSAIC_MASK)) |
1063 (screenSize << REG_G2_BG2CNT_SCREENSIZE_SHIFT) | (charBase <<
1064 REG_G2_BG2CNT_CHARBASE_SHIFT) |
1065 GX_BG_EXTMODE_256x16PLTT | (screenBase << REG_G2_BG2CNT_SCREENBASE_SHIFT) | (areaOver
1066 <<
1067 REG_G2_BG2CNT_AREAOVER_SHIFT));
1068 }
1069
1070
1071 /*---------------------------------------------------------------------------*
1072 Name: G2_GetBG2Control256x16Pltt
1073
1074 Description: Get BG #2 Control State(MAIN engine)
1075
1076 Arguments: BG Control structure.
1077
1078 Returns: none
1079 *---------------------------------------------------------------------------*/
G2_GetBG2Control256x16Pltt(void)1080 static inline GXBg23Control256x16Pltt G2_GetBG2Control256x16Pltt(void)
1081 {
1082 GX_BGMODE_WARNING1(G2_GetBG2Control256x16Pltt, 5);
1083
1084 return *(volatile GXBg23Control256x16Pltt *)REG_BG2CNT_ADDR;
1085 }
1086
1087 /*---------------------------------------------------------------------------*
1088 Name: G2_GetBG2Control256x16Affine
1089
1090 Description: Get BG #2 Control State(MAIN engine)
1091
1092 Arguments: BG Control structure.
1093
1094 Returns: none
1095 *---------------------------------------------------------------------------*/
G2_GetBG2Control256x16Affine(void)1096 static inline GXBg23Control256x16Affine G2_GetBG2Control256x16Affine(void)
1097 {
1098 GX_BGMODE_WARNING1(G2_GetBG2Control256x16Affine, 5);
1099
1100 return *(volatile GXBg23Control256x16Affine *)REG_BG2CNT_ADDR;
1101 }
1102
1103
1104 /*---------------------------------------------------------------------------*
1105 Name: G2S_SetBG2Control256x16Affine
1106
1107 Description: Sets up BG #2 as an extended affine 256 colors x 16 palettes
1108 character BG(SUB engine).
1109
1110 Arguments: screenSize screen size
1111 areaOver select repeat or not repeat
1112 screenBase screen base block
1113 charBase character base block
1114
1115 Returns: none
1116 *---------------------------------------------------------------------------*/
G2S_SetBG2Control256x16Affine(GXBGScrSize256x16Pltt screenSize,GXBGAreaOver areaOver,GXBGScrBase screenBase,GXBGCharBase charBase)1117 static inline void G2S_SetBG2Control256x16Affine(GXBGScrSize256x16Pltt screenSize,
1118 GXBGAreaOver areaOver,
1119 GXBGScrBase screenBase, GXBGCharBase charBase)
1120 {
1121 GX_BG_SCRSIZE_256x16PLTT_ASSERT(screenSize);
1122 GX_BG_AREAOVER_ASSERT(areaOver);
1123 GX_BG_SCRBASE_ASSERT(screenBase);
1124 GX_BG_CHARBASE_ASSERT(charBase);
1125 GXS_BGMODE_WARNING1(G2S_SetBG2Control256x16Affine, 5);
1126
1127 reg_G2S_DB_BG2CNT =
1128 (u16)((reg_G2S_DB_BG2CNT &
1129 (REG_G2S_DB_BG2CNT_PRIORITY_MASK | REG_G2S_DB_BG2CNT_MOSAIC_MASK)) | (screenSize <<
1130 REG_G2S_DB_BG2CNT_SCREENSIZE_SHIFT)
1131 | (charBase << REG_G2S_DB_BG2CNT_CHARBASE_SHIFT) | GX_BG_EXTMODE_256x16PLTT |
1132 (screenBase << REG_G2S_DB_BG2CNT_SCREENBASE_SHIFT) | (areaOver <<
1133 REG_G2S_DB_BG2CNT_AREAOVER_SHIFT));
1134 }
1135
1136
1137 /*---------------------------------------------------------------------------*
1138 Name: G2S_GetBG2Control256x16Pltt
1139
1140 Description: Get BG #2 Control State(MAIN engine)
1141
1142 Arguments: BG Control structure.
1143
1144 Returns: none
1145 *---------------------------------------------------------------------------*/
G2S_GetBG2Control256x16Pltt(void)1146 static inline GXBg23Control256x16Pltt G2S_GetBG2Control256x16Pltt(void)
1147 {
1148 GXS_BGMODE_WARNING1(G2S_GetBG2Control256x16Pltt, 5);
1149
1150 return *(volatile GXBg23Control256x16Pltt *)REG_DB_BG2CNT_ADDR;
1151 }
1152
1153 /*---------------------------------------------------------------------------*
1154 Name: G2S_GetBG2Control256x16Affine
1155
1156 Description: Get BG #2 Control State(MAIN engine)
1157
1158 Arguments: BG Control structure.
1159
1160 Returns: none
1161 *---------------------------------------------------------------------------*/
G2S_GetBG2Control256x16Affine(void)1162 static inline GXBg23Control256x16Affine G2S_GetBG2Control256x16Affine(void)
1163 {
1164 GXS_BGMODE_WARNING1(G2S_GetBG2Control256x16Affine, 5);
1165
1166 return *(volatile GXBg23Control256x16Affine *)REG_DB_BG2CNT_ADDR;
1167 }
1168
1169
1170 /*---------------------------------------------------------------------------*
1171 Name: G2_SetBG2Control256Bmp
1172
1173 Description: Sets up BG #2 as an extended affine 256 colors bitmap
1174 BG(MAIN engine).
1175
1176 Arguments: screenSize screen size
1177 areaOver select repeat or not repeat
1178 screenBase screen base block
1179
1180 Returns: none
1181 *---------------------------------------------------------------------------*/
G2_SetBG2Control256Bmp(GXBGScrSize256Bmp screenSize,GXBGAreaOver areaOver,GXBGBmpScrBase screenBase)1182 static inline void G2_SetBG2Control256Bmp(GXBGScrSize256Bmp screenSize,
1183 GXBGAreaOver areaOver, GXBGBmpScrBase screenBase)
1184 {
1185 GX_BG_SCRSIZE_256BMP_ASSERT(screenSize);
1186 GX_BG_AREAOVER_ASSERT(areaOver);
1187 GX_BG_BMPSCRBASE_ASSERT(screenBase);
1188 GX_BGMODE_WARNING1(G2_SetBG2Control256Bmp, 5);
1189
1190 reg_G2_BG2CNT =
1191 (u16)((reg_G2_BG2CNT & (REG_G2_BG2CNT_PRIORITY_MASK | REG_G2_BG2CNT_MOSAIC_MASK)) |
1192 (screenSize << REG_G2_BG2CNT_SCREENSIZE_SHIFT) | GX_BG_EXTMODE_256BITMAP | (screenBase
1193 <<
1194 REG_G2_BG2CNT_SCREENBASE_SHIFT)
1195 | (areaOver << REG_G2_BG2CNT_AREAOVER_SHIFT));
1196 }
1197
1198
1199 /*---------------------------------------------------------------------------*
1200 Name: G2_GetBG2Control256Bmp
1201
1202 Description: Get BG #2 Control State(MAIN engine)
1203
1204 Arguments: BG Control structure.
1205
1206 Returns: none
1207 *---------------------------------------------------------------------------*/
G2_GetBG2Control256Bmp(void)1208 static inline GXBg23Control256Bmp G2_GetBG2Control256Bmp(void)
1209 {
1210 GX_BGMODE_WARNING1(G2_GetBG2Control256Bmp, 5);
1211
1212 return *(volatile GXBg23Control256Bmp *)REG_BG2CNT_ADDR;
1213 }
1214
1215
1216 /*---------------------------------------------------------------------------*
1217 Name: G2S_SetBG2Control256Bmp
1218
1219 Description: Sets up BG #2 as an extended affine 256 colors bitmap
1220 BG(SUB engine).
1221
1222 Arguments: screenSize screen size
1223 areaOver select repeat or not repeat
1224 screenBase screen base block
1225
1226 Returns: none
1227 *---------------------------------------------------------------------------*/
G2S_SetBG2Control256Bmp(GXBGScrSize256Bmp screenSize,GXBGAreaOver areaOver,GXBGBmpScrBase screenBase)1228 static inline void G2S_SetBG2Control256Bmp(GXBGScrSize256Bmp screenSize,
1229 GXBGAreaOver areaOver, GXBGBmpScrBase screenBase)
1230 {
1231 GX_BG_SCRSIZE_256BMP_ASSERT(screenSize);
1232 GX_BG_AREAOVER_ASSERT(areaOver);
1233 GX_BG_BMPSCRBASE_ASSERT(screenBase);
1234 SDK_ASSERTMSG(screenSize != GX_BG_SCRSIZE_256BMP_512x512,
1235 "SUB 2D engine does not support GX_BG_SCRSIZE_256BMP_512x512");
1236 GXS_BGMODE_WARNING1(G2S_SetBG2Control256Bmp, 5);
1237
1238 reg_G2S_DB_BG2CNT =
1239 (u16)((reg_G2S_DB_BG2CNT &
1240 (REG_G2S_DB_BG2CNT_PRIORITY_MASK | REG_G2S_DB_BG2CNT_MOSAIC_MASK)) | (screenSize <<
1241 REG_G2S_DB_BG2CNT_SCREENSIZE_SHIFT)
1242 | GX_BG_EXTMODE_256BITMAP | (screenBase << REG_G2S_DB_BG2CNT_SCREENBASE_SHIFT) |
1243 (areaOver << REG_G2S_DB_BG2CNT_AREAOVER_SHIFT));
1244 }
1245
1246
1247 /*---------------------------------------------------------------------------*
1248 Name: G2S_GetBG2Control256Bmp
1249
1250 Description: Get BG #2 Control State(SUB engine)
1251
1252 Arguments: BG Control structure.
1253
1254 Returns: none
1255 *---------------------------------------------------------------------------*/
G2S_GetBG2Control256Bmp(void)1256 static inline GXBg23Control256Bmp G2S_GetBG2Control256Bmp(void)
1257 {
1258 GXS_BGMODE_WARNING1(G2S_GetBG2Control256Bmp, 5);
1259
1260 return *(volatile GXBg23Control256Bmp *)REG_DB_BG2CNT_ADDR;
1261 }
1262
1263
1264 /*---------------------------------------------------------------------------*
1265 Name: G2_SetBG2ControlDCBmp
1266
1267 Description: Sets up BG #2 as an extended affine direct color bitmap BG(MAIN engine).
1268
1269 Arguments: screenSize screen size
1270 areaOver select repeat or not repeat
1271 screenBase screen base block
1272
1273 Returns: none
1274 *---------------------------------------------------------------------------*/
G2_SetBG2ControlDCBmp(GXBGScrSizeDcBmp screenSize,GXBGAreaOver areaOver,GXBGBmpScrBase screenBase)1275 static inline void G2_SetBG2ControlDCBmp(GXBGScrSizeDcBmp screenSize,
1276 GXBGAreaOver areaOver, GXBGBmpScrBase screenBase)
1277 {
1278 GX_BG_SCRSIZE_DCBMP_ASSERT(screenSize);
1279 GX_BG_AREAOVER_ASSERT(areaOver);
1280 GX_BG_BMPSCRBASE_ASSERT(screenBase);
1281 GX_BGMODE_WARNING1(G2_SetBG2ControlDCBmp, 5);
1282
1283 reg_G2_BG2CNT =
1284 (u16)((reg_G2_BG2CNT & (REG_G2_BG2CNT_PRIORITY_MASK | REG_G2_BG2CNT_MOSAIC_MASK)) |
1285 (screenSize << REG_G2_BG2CNT_SCREENSIZE_SHIFT) | GX_BG_EXTMODE_DCBITMAP | (screenBase
1286 <<
1287 REG_G2_BG2CNT_SCREENBASE_SHIFT)
1288 | (areaOver << REG_G2_BG2CNT_AREAOVER_SHIFT));
1289 }
1290
1291
1292 /*---------------------------------------------------------------------------*
1293 Name: G2_GetBG2ControlDCBmp
1294
1295 Description: Get BG #2 Control State(MAIN engine)
1296
1297 Arguments: BG Control structure.
1298
1299 Returns: none
1300 *---------------------------------------------------------------------------*/
G2_GetBG2ControlDCBmp(void)1301 static inline GXBg23ControlDCBmp G2_GetBG2ControlDCBmp(void)
1302 {
1303 GX_BGMODE_WARNING1(G2_SetBG2ControlDCBmp, 5);
1304
1305 return *(volatile GXBg23ControlDCBmp *)REG_BG2CNT_ADDR;
1306 }
1307
1308
1309 /*---------------------------------------------------------------------------*
1310 Name: G2S_SetBG2ControlDCBmp
1311
1312 Description: Sets up BG #2 as an extended affine direct color bitmap BG(SUB engine).
1313
1314 Arguments: screenSize screen size
1315 areaOver select repeat or not repeat
1316 screenBase screen base block
1317
1318 Returns: none
1319 *---------------------------------------------------------------------------*/
G2S_SetBG2ControlDCBmp(GXBGScrSizeDcBmp screenSize,GXBGAreaOver areaOver,GXBGBmpScrBase screenBase)1320 static inline void G2S_SetBG2ControlDCBmp(GXBGScrSizeDcBmp screenSize,
1321 GXBGAreaOver areaOver, GXBGBmpScrBase screenBase)
1322 {
1323 GX_BG_SCRSIZE_DCBMP_ASSERT(screenSize);
1324 GX_BG_AREAOVER_ASSERT(areaOver);
1325 GX_BG_BMPSCRBASE_ASSERT(screenBase);
1326 SDK_ASSERTMSG(screenSize != GX_BG_SCRSIZE_DCBMP_512x256,
1327 "SUB 2D engine does not support GX_BG_SCRSIZE_DCBMP_512x256");
1328 SDK_ASSERTMSG(screenSize != GX_BG_SCRSIZE_DCBMP_512x512,
1329 "SUB 2D engine does not support GX_BG_SCRSIZE_DCBMP_512x512");
1330 GXS_BGMODE_WARNING1(G2S_SetBG2ControlDCBmp, 5);
1331
1332 reg_G2S_DB_BG2CNT =
1333 (u16)((reg_G2S_DB_BG2CNT &
1334 (REG_G2S_DB_BG2CNT_PRIORITY_MASK | REG_G2S_DB_BG2CNT_MOSAIC_MASK)) | (screenSize <<
1335 REG_G2S_DB_BG2CNT_SCREENSIZE_SHIFT)
1336 | GX_BG_EXTMODE_DCBITMAP | (screenBase << REG_G2S_DB_BG2CNT_SCREENBASE_SHIFT) |
1337 (areaOver << REG_G2S_DB_BG2CNT_AREAOVER_SHIFT));
1338 }
1339
1340
1341 /*---------------------------------------------------------------------------*
1342 Name: G2S_GetBG2ControlDCBmp
1343
1344 Description: Get BG #2 Control State(SUB engine)
1345
1346 Arguments: BG Control structure.
1347
1348 Returns: none
1349 *---------------------------------------------------------------------------*/
G2S_GetBG2ControlDCBmp(void)1350 static inline GXBg23ControlDCBmp G2S_GetBG2ControlDCBmp(void)
1351 {
1352 GXS_BGMODE_WARNING1(G2S_GetBG2ControlDCBmp, 5);
1353
1354 return *(volatile GXBg23ControlDCBmp *)REG_DB_BG2CNT_ADDR;
1355 }
1356
1357
1358 /*---------------------------------------------------------------------------*
1359 Name: G2_SetBG2ControlLargeBmp
1360
1361 Description: Sets up BG #2 as a large 256 colors bitmap BG(MAIN engine).
1362
1363 Arguments: screenSize screen size
1364 areaOver select repeat or not repeat
1365
1366 Returns: none
1367 *---------------------------------------------------------------------------*/
G2_SetBG2ControlLargeBmp(GXBGScrSizeLargeBmp screenSize,GXBGAreaOver areaOver)1368 static inline void G2_SetBG2ControlLargeBmp(GXBGScrSizeLargeBmp screenSize, GXBGAreaOver areaOver)
1369 {
1370 GX_BG_SCRSIZE_LARGEBMP_ASSERT(screenSize);
1371 GX_BG_AREAOVER_ASSERT(areaOver);
1372 GX_BGMODE_WARNING1(G2_SetBG2ControlLargeBmp, 6);
1373
1374 reg_G2_BG2CNT =
1375 (u16)((reg_G2_BG2CNT & (REG_G2_BG2CNT_PRIORITY_MASK | REG_G2_BG2CNT_MOSAIC_MASK)) |
1376 (screenSize << REG_G2_BG2CNT_SCREENSIZE_SHIFT) | (areaOver <<
1377 REG_G2_BG2CNT_AREAOVER_SHIFT));
1378 }
1379
1380
1381 /*---------------------------------------------------------------------------*
1382 Name: G2_GetBG2ControlLargeBmp
1383
1384 Description: Get BG #2 Control State(MAIN engine)
1385
1386 Arguments: BG Control structure.
1387
1388 Returns: none
1389 *---------------------------------------------------------------------------*/
G2_GetBG2ControlLargeBmp(void)1390 static inline GXBg2ControlLargeBmp G2_GetBG2ControlLargeBmp(void)
1391 {
1392 GX_BGMODE_WARNING1(G2_GetBG2ControlLargeBmp, 6);
1393
1394 return *(volatile GXBg2ControlLargeBmp *)REG_BG2CNT_ADDR;
1395 }
1396
1397
1398 /*---------------------------------------------------------------------------*
1399 Name: G2_GetBG3ExtMode
1400
1401 Description: Get BG #3 Affine Ex mode(MAIN engine)
1402
1403 Arguments: none.
1404
1405 Returns: Affine Ex mode
1406 *---------------------------------------------------------------------------*/
G2_GetBG3ExtMode(void)1407 static inline GXBGExtMode G2_GetBG3ExtMode(void)
1408 {
1409 GX_BGMODE_WARNING3(G2_GetBG3ExtMode, 3, 4, 5);
1410
1411 //return (GXBGExtMode)(reg_G2_BG3CNT &
1412 // ((1 << REG_G2_BG3CNT_CHARBASE_SHIFT) | REG_G2_BG3CNT_COLORMODE_MASK));
1413 return (GXBGExtMode)(reg_G2_BG3CNT &
1414 (((reg_G2_BG3CNT & REG_G2_BG3CNT_COLORMODE_MASK) >> 5) |
1415 REG_G2_BG3CNT_COLORMODE_MASK));
1416 }
1417
1418
1419 /*---------------------------------------------------------------------------*
1420 Name: G2S_GetBG3ExtMode
1421
1422 Description: Get BG #3 Affine Ex mode(SUB engine)
1423
1424 Arguments: none.
1425
1426 Returns: Affine Ex mode
1427 *---------------------------------------------------------------------------*/
G2S_GetBG3ExtMode(void)1428 static inline GXBGExtMode G2S_GetBG3ExtMode(void)
1429 {
1430 GXS_BGMODE_WARNING3(G2S_GetBG3ExtMode, 3, 4, 5);
1431
1432 //return (GXBGExtMode)(reg_G2S_DB_BG3CNT &
1433 // ((1 << REG_G2_BG3CNT_CHARBASE_SHIFT) | REG_G2_BG3CNT_COLORMODE_MASK));
1434 return (GXBGExtMode)(reg_G2S_DB_BG3CNT &
1435 (((reg_G2S_DB_BG3CNT & REG_G2S_DB_BG3CNT_COLORMODE_MASK) >> 5) |
1436 REG_G2S_DB_BG3CNT_COLORMODE_MASK));
1437 }
1438
1439
1440 /*---------------------------------------------------------------------------*
1441 Name: G2_SetBG3ControlText
1442
1443 Description: Sets up BG #3 as a text BG(MAIN engine).
1444
1445 Arguments: screenSize screen size
1446 colorMode color mode
1447 screenBase screen base
1448 charBase character base
1449
1450 Returns: none
1451 *---------------------------------------------------------------------------*/
G2_SetBG3ControlText(GXBGScrSizeText screenSize,GXBGColorMode colorMode,GXBGScrBase screenBase,GXBGCharBase charBase)1452 static inline void G2_SetBG3ControlText(GXBGScrSizeText screenSize,
1453 GXBGColorMode colorMode,
1454 GXBGScrBase screenBase, GXBGCharBase charBase)
1455 {
1456 GX_BG_SCRSIZE_TEXT_ASSERT(screenSize);
1457 GX_BG_COLORMODE_ASSERT(colorMode);
1458 GX_BG_SCRBASE_ASSERT(screenBase);
1459 GX_BG_CHARBASE_ASSERT(charBase);
1460 GX_BGMODE_WARNING1(G2_SetBG3ControlText, 0);
1461
1462 reg_G2_BG3CNT =
1463 (u16)((reg_G2_BG3CNT & (REG_G2_BG3CNT_PRIORITY_MASK | REG_G2_BG3CNT_MOSAIC_MASK)) |
1464 (screenSize << REG_G2_BG3CNT_SCREENSIZE_SHIFT) | (colorMode <<
1465 REG_G2_BG3CNT_COLORMODE_SHIFT) |
1466 (screenBase << REG_G2_BG3CNT_SCREENBASE_SHIFT) | (charBase <<
1467 REG_G2_BG3CNT_CHARBASE_SHIFT));
1468 }
1469
1470
1471 /*---------------------------------------------------------------------------*
1472 Name: G2_GetBG3ControlText
1473
1474 Description: Get BG #3 Control State(MAIN engine)
1475
1476 Arguments: BG Control structure.
1477
1478 Returns: none
1479 *---------------------------------------------------------------------------*/
G2_GetBG3ControlText(void)1480 static inline GXBg23ControlText G2_GetBG3ControlText(void)
1481 {
1482 return *(volatile GXBg23ControlText *)REG_BG3CNT_ADDR;
1483 }
1484
1485
1486 /*---------------------------------------------------------------------------*
1487 Name: G2S_SetBG3ControlText
1488
1489 Description: Sets up BG #3 as a text BG(SUB engine).
1490
1491 Arguments: screenSize screen size
1492 colorMode color mode
1493 screenBase screen base
1494 charBase character base
1495
1496 Returns: none
1497 *---------------------------------------------------------------------------*/
G2S_SetBG3ControlText(GXBGScrSizeText screenSize,GXBGColorMode colorMode,GXBGScrBase screenBase,GXBGCharBase charBase)1498 static inline void G2S_SetBG3ControlText(GXBGScrSizeText screenSize,
1499 GXBGColorMode colorMode,
1500 GXBGScrBase screenBase, GXBGCharBase charBase)
1501 {
1502 GX_BG_SCRSIZE_TEXT_ASSERT(screenSize);
1503 GX_BG_COLORMODE_ASSERT(colorMode);
1504 GX_BG_SCRBASE_ASSERT(screenBase);
1505 GX_BG_CHARBASE_ASSERT(charBase);
1506 GXS_BGMODE_WARNING1(G2S_SetBG3ControlText, 0);
1507
1508 reg_G2S_DB_BG3CNT =
1509 (u16)((reg_G2S_DB_BG3CNT &
1510 (REG_G2S_DB_BG3CNT_PRIORITY_MASK | REG_G2S_DB_BG3CNT_MOSAIC_MASK)) | (screenSize <<
1511 REG_G2S_DB_BG3CNT_SCREENSIZE_SHIFT)
1512 | (colorMode << REG_G2S_DB_BG3CNT_COLORMODE_SHIFT) | (screenBase <<
1513 REG_G2S_DB_BG3CNT_SCREENBASE_SHIFT)
1514 | (charBase << REG_G2S_DB_BG3CNT_CHARBASE_SHIFT));
1515 }
1516
1517
1518 /*---------------------------------------------------------------------------*
1519 Name: G2S_GetBG3ControlText
1520
1521 Description: Get BG #3 Control State(SUB engine)
1522
1523 Arguments: BG Control structure.
1524
1525 Returns: none
1526 *---------------------------------------------------------------------------*/
G2S_GetBG3ControlText(void)1527 static inline GXBg23ControlText G2S_GetBG3ControlText(void)
1528 {
1529 return *(volatile GXBg23ControlText *)REG_DB_BG3CNT_ADDR;
1530 }
1531
1532
1533 /*---------------------------------------------------------------------------*
1534 Name: G2_SetBG3ControlAffine
1535
1536 Description: Sets up BG #3 as an affine BG(MAIN engine).
1537
1538 Arguments: screenSize screen size
1539 areaOver select repeat or not repeat
1540 screenBase screen base block
1541 charBase character base block
1542
1543 Returns: none
1544 *---------------------------------------------------------------------------*/
G2_SetBG3ControlAffine(GXBGScrSizeAffine screenSize,GXBGAreaOver areaOver,GXBGScrBase screenBase,GXBGCharBase charBase)1545 static inline void G2_SetBG3ControlAffine(GXBGScrSizeAffine screenSize,
1546 GXBGAreaOver areaOver,
1547 GXBGScrBase screenBase, GXBGCharBase charBase)
1548 {
1549 GX_BG_SCRSIZE_AFFINE_ASSERT(screenSize);
1550 GX_BG_AREAOVER_ASSERT(areaOver);
1551 GX_BG_SCRBASE_ASSERT(screenBase);
1552 GX_BG_CHARBASE_ASSERT(charBase);
1553 GX_BGMODE_WARNING2(G2_SetBG3ControlAffine, 1, 2);
1554
1555 reg_G2_BG3CNT =
1556 (u16)((reg_G2_BG3CNT & (REG_G2_BG3CNT_PRIORITY_MASK | REG_G2_BG3CNT_MOSAIC_MASK)) |
1557 (screenSize << REG_G2_BG3CNT_SCREENSIZE_SHIFT) | (screenBase <<
1558 REG_G2_BG3CNT_SCREENBASE_SHIFT) |
1559 (charBase << REG_G2_BG3CNT_CHARBASE_SHIFT) | (areaOver <<
1560 REG_G2_BG3CNT_AREAOVER_SHIFT));
1561 }
1562
1563
1564 /*---------------------------------------------------------------------------*
1565 Name: G2_GetBG3ControlAffine
1566
1567 Description: Get BG #3 Control State(MAIN engine)
1568
1569 Arguments: BG Control structure.
1570
1571 Returns: none
1572 *---------------------------------------------------------------------------*/
G2_GetBG3ControlAffine(void)1573 static inline GXBg23ControlAffine G2_GetBG3ControlAffine(void)
1574 {
1575 return *(volatile GXBg23ControlAffine *)REG_BG3CNT_ADDR;
1576 }
1577
1578
1579 /*---------------------------------------------------------------------------*
1580 Name: G2S_SetBG3ControlAffine
1581
1582 Description: Sets up BG #3 as an affine BG(SUB engine).
1583
1584 Arguments: screenSize screen size
1585 areaOver select repeat or not repeat
1586 screenBase screen base block
1587 charBase character base block
1588
1589 Returns: none
1590 *---------------------------------------------------------------------------*/
G2S_SetBG3ControlAffine(GXBGScrSizeAffine screenSize,GXBGAreaOver areaOver,GXBGScrBase screenBase,GXBGCharBase charBase)1591 static inline void G2S_SetBG3ControlAffine(GXBGScrSizeAffine screenSize,
1592 GXBGAreaOver areaOver,
1593 GXBGScrBase screenBase, GXBGCharBase charBase)
1594 {
1595 GX_BG_SCRSIZE_AFFINE_ASSERT(screenSize);
1596 GX_BG_AREAOVER_ASSERT(areaOver);
1597 GX_BG_SCRBASE_ASSERT(screenBase);
1598 GX_BG_CHARBASE_ASSERT(charBase);
1599 GXS_BGMODE_WARNING2(G2S_SetBG3ControlAffine, 1, 2);
1600
1601 reg_G2S_DB_BG3CNT =
1602 (u16)((reg_G2S_DB_BG3CNT &
1603 (REG_G2S_DB_BG3CNT_PRIORITY_MASK | REG_G2S_DB_BG3CNT_MOSAIC_MASK)) | (screenSize <<
1604 REG_G2S_DB_BG3CNT_SCREENSIZE_SHIFT)
1605 | (screenBase << REG_G2S_DB_BG3CNT_SCREENBASE_SHIFT) | (charBase <<
1606 REG_G2S_DB_BG3CNT_CHARBASE_SHIFT)
1607 | (areaOver << REG_G2S_DB_BG3CNT_AREAOVER_SHIFT));
1608 }
1609
1610
1611 /*---------------------------------------------------------------------------*
1612 Name: G2S_GetBG3ControlAffine
1613
1614 Description: Get BG #3 Control State(SUB engine)
1615
1616 Arguments: BG Control structure.
1617
1618 Returns: none
1619 *---------------------------------------------------------------------------*/
G2S_GetBG3ControlAffine(void)1620 static inline GXBg23ControlAffine G2S_GetBG3ControlAffine(void)
1621 {
1622 return *(volatile GXBg23ControlAffine *)REG_DB_BG3CNT_ADDR;
1623 }
1624
1625
1626 /*---------------------------------------------------------------------------*
1627 Name: G2_SetBG3Control256x16Affine
1628
1629 Description: Sets up BG #3 as an extended affine 256 colors x 16 palettes
1630 character BG(MAIN engine).
1631
1632 Arguments: screenSize screen size
1633 areaOver select repeat or not repeat
1634 screenBase screen base block
1635 charBase character base block
1636
1637 Returns: none
1638 *---------------------------------------------------------------------------*/
G2_SetBG3Control256x16Affine(GXBGScrSize256x16Pltt screenSize,GXBGAreaOver areaOver,GXBGScrBase screenBase,GXBGCharBase charBase)1639 static inline void G2_SetBG3Control256x16Affine(GXBGScrSize256x16Pltt screenSize,
1640 GXBGAreaOver areaOver,
1641 GXBGScrBase screenBase, GXBGCharBase charBase)
1642 {
1643 GX_BG_SCRSIZE_256x16PLTT_ASSERT(screenSize);
1644 GX_BG_AREAOVER_ASSERT(areaOver);
1645 GX_BG_SCRBASE_ASSERT(screenBase);
1646 GX_BG_CHARBASE_ASSERT(charBase);
1647 GX_BGMODE_WARNING3(G2_SetBG3Control256x16Affine, 3, 4, 5);
1648
1649 reg_G2_BG3CNT =
1650 (u16)((reg_G2_BG3CNT & (REG_G2_BG3CNT_PRIORITY_MASK | REG_G2_BG3CNT_MOSAIC_MASK)) |
1651 (screenSize << REG_G2_BG3CNT_SCREENSIZE_SHIFT) | (charBase <<
1652 REG_G2_BG3CNT_CHARBASE_SHIFT) |
1653 GX_BG_EXTMODE_256x16PLTT | (screenBase << REG_G2_BG3CNT_SCREENBASE_SHIFT) | (areaOver
1654 <<
1655 REG_G2_BG3CNT_AREAOVER_SHIFT));
1656 }
1657
1658
1659 /*---------------------------------------------------------------------------*
1660 Name: G2_GetBG3Control256x16Pltt
1661
1662 Description: Get BG #3 Control State(MAIN engine)
1663
1664 Arguments: BG Control structure.
1665
1666 Returns: none
1667 *---------------------------------------------------------------------------*/
G2_GetBG3Control256x16Pltt(void)1668 static inline GXBg23Control256x16Pltt G2_GetBG3Control256x16Pltt(void)
1669 {
1670 return *(volatile GXBg23Control256x16Pltt *)REG_BG3CNT_ADDR;
1671 }
1672
1673 /*---------------------------------------------------------------------------*
1674 Name: G2_GetBG3Control256x16Affine
1675
1676 Description: Get BG #3 Control State(MAIN engine)
1677
1678 Arguments: BG Control structure.
1679
1680 Returns: none
1681 *---------------------------------------------------------------------------*/
G2_GetBG3Control256x16Affine(void)1682 static inline GXBg23Control256x16Affine G2_GetBG3Control256x16Affine(void)
1683 {
1684 return *(volatile GXBg23Control256x16Affine *)REG_BG3CNT_ADDR;
1685 }
1686
1687
1688 /*---------------------------------------------------------------------------*
1689 Name: G2S_SetBG3Control256x16Affine
1690
1691 Description: Sets up BG #3 as an extended affine 256 colors x 16 palettes
1692 character BG(SUB engine).
1693
1694 Arguments: screenSize screen size
1695 areaOver select repeat or not repeat
1696 screenBase screen base block
1697
1698 Returns: none
1699 *---------------------------------------------------------------------------*/
G2S_SetBG3Control256x16Affine(GXBGScrSize256x16Pltt screenSize,GXBGAreaOver areaOver,GXBGScrBase screenBase,GXBGCharBase charBase)1700 static inline void G2S_SetBG3Control256x16Affine(GXBGScrSize256x16Pltt screenSize,
1701 GXBGAreaOver areaOver,
1702 GXBGScrBase screenBase, GXBGCharBase charBase)
1703 {
1704 GX_BG_SCRSIZE_256x16PLTT_ASSERT(screenSize);
1705 GX_BG_AREAOVER_ASSERT(areaOver);
1706 GX_BG_SCRBASE_ASSERT(screenBase);
1707 GX_BG_CHARBASE_ASSERT(charBase);
1708 GXS_BGMODE_WARNING3(G2S_SetBG3Control256x16Affine, 3, 4, 5);
1709
1710 reg_G2S_DB_BG3CNT =
1711 (u16)((reg_G2S_DB_BG3CNT &
1712 (REG_G2S_DB_BG3CNT_PRIORITY_MASK | REG_G2S_DB_BG3CNT_MOSAIC_MASK)) | (screenSize <<
1713 REG_G2S_DB_BG3CNT_SCREENSIZE_SHIFT)
1714 | (charBase << REG_G2S_DB_BG3CNT_CHARBASE_SHIFT) | GX_BG_EXTMODE_256x16PLTT |
1715 (screenBase << REG_G2S_DB_BG3CNT_SCREENBASE_SHIFT) | (areaOver <<
1716 REG_G2S_DB_BG3CNT_AREAOVER_SHIFT));
1717 }
1718
1719
1720 /*---------------------------------------------------------------------------*
1721 Name: G2S_GetBG3Control256x16Pltt
1722
1723 Description: Get BG #3 Control State(SUB engine)
1724
1725 Arguments: BG Control structure.
1726
1727 Returns: none
1728 *---------------------------------------------------------------------------*/
G2S_GetBG3Control256x16Pltt(void)1729 static inline GXBg23Control256x16Pltt G2S_GetBG3Control256x16Pltt(void)
1730 {
1731 return *(volatile GXBg23Control256x16Pltt *)REG_DB_BG3CNT_ADDR;
1732 }
1733
1734 /*---------------------------------------------------------------------------*
1735 Name: G2S_GetBG3Control256x16Affine
1736
1737 Description: Get BG #3 Control State(SUB engine)
1738
1739 Arguments: BG Control structure.
1740
1741 Returns: none
1742 *---------------------------------------------------------------------------*/
G2S_GetBG3Control256x16Affine(void)1743 static inline GXBg23Control256x16Affine G2S_GetBG3Control256x16Affine(void)
1744 {
1745 return *(volatile GXBg23Control256x16Affine *)REG_DB_BG3CNT_ADDR;
1746 }
1747
1748
1749 /*---------------------------------------------------------------------------*
1750 Name: G2_SetBG3ControlExt256Bmp
1751
1752 Description: Sets up BG #3 as an extended affine 256 colors bitmap BG(MAIN engine).
1753
1754 Arguments: screenSize screen size
1755 areaOver select repeat or not repeat
1756 screenBase screen base block
1757
1758 Returns: none
1759 *---------------------------------------------------------------------------*/
G2_SetBG3Control256Bmp(GXBGScrSize256Bmp screenSize,GXBGAreaOver areaOver,GXBGBmpScrBase screenBase)1760 static inline void G2_SetBG3Control256Bmp(GXBGScrSize256Bmp screenSize,
1761 GXBGAreaOver areaOver, GXBGBmpScrBase screenBase)
1762 {
1763 GX_BG_SCRSIZE_256BMP_ASSERT(screenSize);
1764 GX_BG_AREAOVER_ASSERT(areaOver);
1765 GX_BG_BMPSCRBASE_ASSERT(screenBase);
1766 GX_BGMODE_WARNING3(G2_SetBG3Control256Bmp, 3, 4, 5);
1767
1768 reg_G2_BG3CNT =
1769 (u16)((reg_G2_BG3CNT & (REG_G2_BG3CNT_PRIORITY_MASK | REG_G2_BG3CNT_MOSAIC_MASK)) |
1770 (screenSize << REG_G2_BG3CNT_SCREENSIZE_SHIFT) | GX_BG_EXTMODE_256BITMAP | (screenBase
1771 <<
1772 REG_G2_BG3CNT_SCREENBASE_SHIFT)
1773 | (areaOver << REG_G2_BG3CNT_AREAOVER_SHIFT));
1774 }
1775
1776
1777 /*---------------------------------------------------------------------------*
1778 Name: G2_GetBG3Control256Bmp
1779
1780 Description: Get BG #3 Control State(MAIN engine)
1781
1782 Arguments: BG Control structure.
1783
1784 Returns: none
1785 *---------------------------------------------------------------------------*/
G2_GetBG3Control256Bmp(void)1786 static inline GXBg23Control256Bmp G2_GetBG3Control256Bmp(void)
1787 {
1788 return *(volatile GXBg23Control256Bmp *)REG_BG3CNT_ADDR;
1789 }
1790
1791
1792 /*---------------------------------------------------------------------------*
1793 Name: G2S_SetBG3ControlExt256Bmp
1794
1795 Description: Sets up BG #3 as an extended affine 256 colors bitmap BG(SUB engine).
1796
1797 Arguments: screenSize screen size
1798 areaOver select repeat or not repeat
1799 screenBase screen base block
1800
1801 Returns: none
1802 *---------------------------------------------------------------------------*/
G2S_SetBG3Control256Bmp(GXBGScrSize256Bmp screenSize,GXBGAreaOver areaOver,GXBGBmpScrBase screenBase)1803 static inline void G2S_SetBG3Control256Bmp(GXBGScrSize256Bmp screenSize,
1804 GXBGAreaOver areaOver, GXBGBmpScrBase screenBase)
1805 {
1806 GX_BG_SCRSIZE_256BMP_ASSERT(screenSize);
1807 GX_BG_AREAOVER_ASSERT(areaOver);
1808 GX_BG_BMPSCRBASE_ASSERT(screenBase);
1809 SDK_ASSERTMSG(screenSize != GX_BG_SCRSIZE_256BMP_512x512,
1810 "SUB 2D engine does not support GX_BG_SCRSIZE_256BMP_512x512");
1811 GXS_BGMODE_WARNING3(G2S_SetBG3Control256Bmp, 3, 4, 5);
1812
1813 reg_G2S_DB_BG3CNT =
1814 (u16)((reg_G2S_DB_BG3CNT &
1815 (REG_G2S_DB_BG3CNT_PRIORITY_MASK | REG_G2S_DB_BG3CNT_MOSAIC_MASK)) | (screenSize <<
1816 REG_G2S_DB_BG3CNT_SCREENSIZE_SHIFT)
1817 | GX_BG_EXTMODE_256BITMAP | (screenBase << REG_G2S_DB_BG3CNT_SCREENBASE_SHIFT) |
1818 (areaOver << REG_G2S_DB_BG3CNT_AREAOVER_SHIFT));
1819 }
1820
1821
1822 /*---------------------------------------------------------------------------*
1823 Name: G2S_GetBG3Control256Bmp
1824
1825 Description: Get BG #3 Control State(SUB engine)
1826
1827 Arguments: BG Control structure.
1828
1829 Returns: none
1830 *---------------------------------------------------------------------------*/
G2S_GetBG3Control256Bmp(void)1831 static inline GXBg23Control256Bmp G2S_GetBG3Control256Bmp(void)
1832 {
1833 return *(volatile GXBg23Control256Bmp *)REG_DB_BG3CNT_ADDR;
1834 }
1835
1836
1837 /*---------------------------------------------------------------------------*
1838 Name: G2_SetBG3ControlDCBmp
1839
1840 Description: Sets up BG #3 as an extended affine direct color bitmap BG(MAIN engine).
1841
1842 Arguments: screenSize screen size
1843 areaOver select repeat or not repeat
1844 screenBase screen base block
1845
1846 Returns: none
1847 *---------------------------------------------------------------------------*/
G2_SetBG3ControlDCBmp(GXBGScrSizeDcBmp screenSize,GXBGAreaOver areaOver,GXBGBmpScrBase screenBase)1848 static inline void G2_SetBG3ControlDCBmp(GXBGScrSizeDcBmp screenSize,
1849 GXBGAreaOver areaOver, GXBGBmpScrBase screenBase)
1850 {
1851 GX_BG_SCRSIZE_DCBMP_ASSERT(screenSize);
1852 GX_BG_AREAOVER_ASSERT(areaOver);
1853 GX_BG_BMPSCRBASE_ASSERT(screenBase);
1854 GX_BGMODE_WARNING3(G2_SetBG3ControlDCBmp, 3, 4, 5);
1855
1856 reg_G2_BG3CNT =
1857 (u16)((reg_G2_BG3CNT & (REG_G2_BG3CNT_PRIORITY_MASK | REG_G2_BG3CNT_MOSAIC_MASK)) |
1858 (screenSize << REG_G2_BG3CNT_SCREENSIZE_SHIFT) | GX_BG_EXTMODE_DCBITMAP | (screenBase
1859 <<
1860 REG_G2_BG3CNT_SCREENBASE_SHIFT)
1861 | (areaOver << REG_G2_BG3CNT_AREAOVER_SHIFT));
1862 }
1863
1864
1865 /*---------------------------------------------------------------------------*
1866 Name: G2_GetBG3ControlDCBmp
1867
1868 Description: Get BG #3 Control State(MAIN engine)
1869
1870 Arguments: BG Control structure.
1871
1872 Returns: none
1873 *---------------------------------------------------------------------------*/
G2_GetBG3ControlDCBmp(void)1874 static inline GXBg23ControlDCBmp G2_GetBG3ControlDCBmp(void)
1875 {
1876 return *(volatile GXBg23ControlDCBmp *)REG_BG3CNT_ADDR;
1877 }
1878
1879
1880
1881
1882 /*---------------------------------------------------------------------------*
1883 Name: G2S_SetBG3ControlDCBmp
1884
1885 Description: Sets up BG #3 as an extended affine direct color bitmap BG(SUB engine).
1886
1887 Arguments: screenSize screen size
1888 areaOver select repeat or not repeat
1889 screenBase screen base block
1890
1891 Returns: none
1892 *---------------------------------------------------------------------------*/
G2S_SetBG3ControlDCBmp(GXBGScrSizeDcBmp screenSize,GXBGAreaOver areaOver,GXBGBmpScrBase screenBase)1893 static inline void G2S_SetBG3ControlDCBmp(GXBGScrSizeDcBmp screenSize,
1894 GXBGAreaOver areaOver, GXBGBmpScrBase screenBase)
1895 {
1896 GX_BG_SCRSIZE_DCBMP_ASSERT(screenSize);
1897 GX_BG_AREAOVER_ASSERT(areaOver);
1898 GX_BG_BMPSCRBASE_ASSERT(screenBase);
1899 GXS_BGMODE_WARNING3(G2S_SetBG3ControlDCBmp, 3, 4, 5);
1900
1901 reg_G2S_DB_BG3CNT =
1902 (u16)((reg_G2S_DB_BG3CNT &
1903 (REG_G2S_DB_BG3CNT_PRIORITY_MASK | REG_G2S_DB_BG3CNT_MOSAIC_MASK)) | (screenSize <<
1904 REG_G2S_DB_BG3CNT_SCREENSIZE_SHIFT)
1905 | GX_BG_EXTMODE_DCBITMAP | (screenBase << REG_G2S_DB_BG3CNT_SCREENBASE_SHIFT) |
1906 (areaOver << REG_G2S_DB_BG3CNT_AREAOVER_SHIFT));
1907 }
1908
1909
1910 /*---------------------------------------------------------------------------*
1911 Name: G2S_GetBG3ControlDCBmp
1912
1913 Description: Get BG #3 Control State(MAIN engine)
1914
1915 Arguments: BG Control structure.
1916
1917 Returns: none
1918 *---------------------------------------------------------------------------*/
G2S_GetBG3ControlDCBmp(void)1919 static inline GXBg23ControlDCBmp G2S_GetBG3ControlDCBmp(void)
1920 {
1921 return *(volatile GXBg23ControlDCBmp *)REG_DB_BG3CNT_ADDR;
1922 }
1923
1924
1925 /*---------------------------------------------------------------------------*
1926 Name: G2_BG0Mosaic
1927
1928 Description: Enable/Disable mosaic on BG #0(MAIN engine).
1929
1930 Arguments: enable if FALSE, mosaic is disabled,
1931 otherwise, mosaic is enabled.
1932 Returns: none
1933 *---------------------------------------------------------------------------*/
G2_BG0Mosaic(BOOL enable)1934 static inline void G2_BG0Mosaic(BOOL enable)
1935 {
1936 if (enable)
1937 {
1938 reg_G2_BG0CNT |= REG_G2_BG0CNT_MOSAIC_MASK;
1939 }
1940 else
1941 {
1942 reg_G2_BG0CNT &= ~REG_G2_BG0CNT_MOSAIC_MASK;
1943 }
1944 }
1945
1946
1947 /*---------------------------------------------------------------------------*
1948 Name: G2S_BG0Mosaic
1949
1950 Description: Enable/Disable mosaic on BG #0(SUB engine).
1951
1952 Arguments: enable if FALSE, mosaic is disabled,
1953 otherwise, mosaic is enabled.
1954 Returns: none
1955 *---------------------------------------------------------------------------*/
G2S_BG0Mosaic(BOOL enable)1956 static inline void G2S_BG0Mosaic(BOOL enable)
1957 {
1958 if (enable)
1959 {
1960 reg_G2S_DB_BG0CNT |= REG_G2S_DB_BG0CNT_MOSAIC_MASK;
1961 }
1962 else
1963 {
1964 reg_G2S_DB_BG0CNT &= ~REG_G2S_DB_BG0CNT_MOSAIC_MASK;
1965 }
1966 }
1967
1968
1969 /*---------------------------------------------------------------------------*
1970 Name: G2_BG1Mosaic
1971
1972 Description: Enable/Disable mosaic on BG #1(MAIN engine).
1973
1974 Arguments: enable if FALSE, mosaic is disabled,
1975 otherwise, mosaic is enabled.
1976 Returns: none
1977 *---------------------------------------------------------------------------*/
G2_BG1Mosaic(BOOL enable)1978 static inline void G2_BG1Mosaic(BOOL enable)
1979 {
1980 if (enable)
1981 {
1982 reg_G2_BG1CNT |= REG_G2_BG1CNT_MOSAIC_MASK;
1983 }
1984 else
1985 {
1986 reg_G2_BG1CNT &= ~REG_G2_BG1CNT_MOSAIC_MASK;
1987 }
1988 }
1989
1990
1991 /*---------------------------------------------------------------------------*
1992 Name: G2S_BG1Mosaic
1993
1994 Description: Enable/Disable mosaic on BG #1(SUB engine).
1995
1996 Arguments: enable if FALSE, mosaic is disabled,
1997 otherwise, mosaic is enabled.
1998 Returns: none
1999 *---------------------------------------------------------------------------*/
G2S_BG1Mosaic(BOOL enable)2000 static inline void G2S_BG1Mosaic(BOOL enable)
2001 {
2002 if (enable)
2003 {
2004 reg_G2S_DB_BG1CNT |= REG_G2S_DB_BG1CNT_MOSAIC_MASK;
2005 }
2006 else
2007 {
2008 reg_G2S_DB_BG1CNT &= ~REG_G2S_DB_BG1CNT_MOSAIC_MASK;
2009 }
2010 }
2011
2012
2013 /*---------------------------------------------------------------------------*
2014 Name: G2_BG2Mosaic
2015
2016 Description: Enable/Disable mosaic on BG #2(MAIN engine).
2017
2018 Arguments: enable if FALSE, mosaic is disabled,
2019 otherwise, mosaic is enabled.
2020 Returns: none
2021 *---------------------------------------------------------------------------*/
G2_BG2Mosaic(BOOL enable)2022 static inline void G2_BG2Mosaic(BOOL enable)
2023 {
2024 if (enable)
2025 {
2026 reg_G2_BG2CNT |= REG_G2_BG2CNT_MOSAIC_MASK;
2027 }
2028 else
2029 {
2030 reg_G2_BG2CNT &= ~REG_G2_BG2CNT_MOSAIC_MASK;
2031 }
2032 }
2033
2034
2035 /*---------------------------------------------------------------------------*
2036 Name: G2S_BG2Mosaic
2037
2038 Description: Enable/Disable mosaic on BG #2(SUB engine).
2039
2040 Arguments: enable if FALSE, mosaic is disabled,
2041 otherwise, mosaic is enabled.
2042 Returns: none
2043 *---------------------------------------------------------------------------*/
G2S_BG2Mosaic(BOOL enable)2044 static inline void G2S_BG2Mosaic(BOOL enable)
2045 {
2046 if (enable)
2047 {
2048 reg_G2S_DB_BG2CNT |= REG_G2S_DB_BG2CNT_MOSAIC_MASK;
2049 }
2050 else
2051 {
2052 reg_G2S_DB_BG2CNT &= ~REG_G2S_DB_BG2CNT_MOSAIC_MASK;
2053 }
2054 }
2055
2056
2057 /*---------------------------------------------------------------------------*
2058 Name: G2_BG3Mosaic
2059
2060 Description: Enable/Disable mosaic on BG #3(MAIN engine).
2061
2062 Arguments: enable if FALSE, mosaic is disabled,
2063 otherwise, mosaic is enabled.
2064 Returns: none
2065 *---------------------------------------------------------------------------*/
G2_BG3Mosaic(BOOL enable)2066 static inline void G2_BG3Mosaic(BOOL enable)
2067 {
2068 if (enable)
2069 {
2070 reg_G2_BG3CNT |= REG_G2_BG3CNT_MOSAIC_MASK;
2071 }
2072 else
2073 {
2074 reg_G2_BG3CNT &= ~REG_G2_BG3CNT_MOSAIC_MASK;
2075 }
2076 }
2077
2078
2079 /*---------------------------------------------------------------------------*
2080 Name: G2S_BG3Mosaic
2081
2082 Description: Enable/Disable mosaic on BG #3(SUB engine).
2083
2084 Arguments: enable if FALSE, mosaic is disabled,
2085 otherwise, mosaic is enabled.
2086 Returns: none
2087 *---------------------------------------------------------------------------*/
G2S_BG3Mosaic(BOOL enable)2088 static inline void G2S_BG3Mosaic(BOOL enable)
2089 {
2090 if (enable)
2091 {
2092 reg_G2S_DB_BG3CNT |= REG_G2S_DB_BG3CNT_MOSAIC_MASK;
2093 }
2094 else
2095 {
2096 reg_G2S_DB_BG3CNT &= ~REG_G2S_DB_BG3CNT_MOSAIC_MASK;
2097 }
2098 }
2099
2100
2101 /*---------------------------------------------------------------------------*
2102 Name: G2_SetBG0Priority
2103
2104 Description: Specifies the priority of BG #0(MAIN engine)
2105
2106 Arguments: priority the priority of BG #0 plane
2107
2108 Returns: none
2109 *---------------------------------------------------------------------------*/
G2_SetBG0Priority(int priority)2110 static inline void G2_SetBG0Priority(int priority)
2111 {
2112 GX_BG_PRIORITY_ASSERT(priority);
2113
2114 reg_G2_BG0CNT = (u16)((reg_G2_BG0CNT & ~REG_G2_BG0CNT_PRIORITY_MASK) |
2115 (priority << REG_G2_BG0CNT_PRIORITY_SHIFT));
2116 }
2117
2118
2119 /*---------------------------------------------------------------------------*
2120 Name: G2S_SetBG0Priority
2121
2122 Description: Specifies the priority of BG #0(SUB engine)
2123
2124 Arguments: priority the priority of BG #0 plane
2125
2126 Returns: none
2127 *---------------------------------------------------------------------------*/
G2S_SetBG0Priority(int priority)2128 static inline void G2S_SetBG0Priority(int priority)
2129 {
2130 GX_BG_PRIORITY_ASSERT(priority);
2131
2132 reg_G2S_DB_BG0CNT = (u16)((reg_G2S_DB_BG0CNT & ~REG_G2S_DB_BG0CNT_PRIORITY_MASK) |
2133 (priority << REG_G2S_DB_BG0CNT_PRIORITY_SHIFT));
2134 }
2135
2136
2137 /*---------------------------------------------------------------------------*
2138 Name: G2_SetBG1Priority
2139
2140 Description: Specifies the priority of BG #1(MAIN engine)
2141
2142 Arguments: priority the priority of BG #1 plane
2143
2144 Returns: none
2145 *---------------------------------------------------------------------------*/
G2_SetBG1Priority(int priority)2146 static inline void G2_SetBG1Priority(int priority)
2147 {
2148 GX_BG_PRIORITY_ASSERT(priority);
2149
2150 reg_G2_BG1CNT = (u16)((reg_G2_BG1CNT & ~REG_G2_BG1CNT_PRIORITY_MASK) |
2151 (priority << REG_G2_BG1CNT_PRIORITY_SHIFT));
2152 }
2153
2154
2155 /*---------------------------------------------------------------------------*
2156 Name: G2S_SetBG1Priority
2157
2158 Description: Specifies the priority of BG #1(SUB engine)
2159
2160 Arguments: priority the priority of BG #1 plane
2161
2162 Returns: none
2163 *---------------------------------------------------------------------------*/
G2S_SetBG1Priority(int priority)2164 static inline void G2S_SetBG1Priority(int priority)
2165 {
2166 GX_BG_PRIORITY_ASSERT(priority);
2167
2168 reg_G2S_DB_BG1CNT = (u16)((reg_G2S_DB_BG1CNT & ~REG_G2S_DB_BG1CNT_PRIORITY_MASK) |
2169 (priority << REG_G2S_DB_BG1CNT_PRIORITY_SHIFT));
2170 }
2171
2172
2173 /*---------------------------------------------------------------------------*
2174 Name: G2_SetBG2Priority
2175
2176 Description: Specifies the priority of BG #2(MAIN engine)
2177
2178 Arguments: priority the priority of BG #2 plane
2179
2180 Returns: none
2181 *---------------------------------------------------------------------------*/
G2_SetBG2Priority(int priority)2182 static inline void G2_SetBG2Priority(int priority)
2183 {
2184 GX_BG_PRIORITY_ASSERT(priority);
2185
2186 reg_G2_BG2CNT = (u16)((reg_G2_BG2CNT & ~REG_G2_BG2CNT_PRIORITY_MASK) |
2187 (priority << REG_G2_BG2CNT_PRIORITY_SHIFT));
2188 }
2189
2190
2191 /*---------------------------------------------------------------------------*
2192 Name: G2S_SetBG2Priority
2193
2194 Description: Specifies the priority of BG #2(SUB engine)
2195
2196 Arguments: priority the priority of BG #2 plane
2197
2198 Returns: none
2199 *---------------------------------------------------------------------------*/
G2S_SetBG2Priority(int priority)2200 static inline void G2S_SetBG2Priority(int priority)
2201 {
2202 GX_BG_PRIORITY_ASSERT(priority);
2203
2204 reg_G2S_DB_BG2CNT = (u16)((reg_G2S_DB_BG2CNT & ~REG_G2S_DB_BG2CNT_PRIORITY_MASK) |
2205 (priority << REG_G2S_DB_BG2CNT_PRIORITY_SHIFT));
2206 }
2207
2208
2209 /*---------------------------------------------------------------------------*
2210 Name: G2_SetBG3Priority
2211
2212 Description: Specifies the priority of BG #3(MAIN engine)
2213
2214 Arguments: priority the priority of BG #3 plane
2215
2216 Returns: none
2217 *---------------------------------------------------------------------------*/
G2_SetBG3Priority(int priority)2218 static inline void G2_SetBG3Priority(int priority)
2219 {
2220 GX_BG_PRIORITY_ASSERT(priority);
2221
2222 reg_G2_BG3CNT = (u16)((reg_G2_BG3CNT & ~REG_G2_BG3CNT_PRIORITY_MASK) |
2223 (priority << REG_G2_BG3CNT_PRIORITY_SHIFT));
2224 }
2225
2226
2227 /*---------------------------------------------------------------------------*
2228 Name: G2S_SetBG3Priority
2229
2230 Description: Specifies the priority of BG #3(SUB engine)
2231
2232 Arguments: priority the priority of BG #3 plane
2233
2234 Returns: none
2235 *---------------------------------------------------------------------------*/
G2S_SetBG3Priority(int priority)2236 static inline void G2S_SetBG3Priority(int priority)
2237 {
2238 GX_BG_PRIORITY_ASSERT(priority);
2239
2240 reg_G2S_DB_BG3CNT = (u16)((reg_G2S_DB_BG3CNT & ~REG_G2S_DB_BG3CNT_PRIORITY_MASK) |
2241 (priority << REG_G2S_DB_BG3CNT_PRIORITY_SHIFT));
2242 }
2243
2244
2245 /*---------------------------------------------------------------------------*
2246 Name: G2_GetOBJCharPtr
2247
2248 Description: Always returns (void*)HW_OBJ_VRAM
2249
2250 Arguments: none
2251
2252 Returns: a pointer to the character data of OBJs
2253 *---------------------------------------------------------------------------*/
G2_GetOBJCharPtr()2254 static inline void *G2_GetOBJCharPtr()
2255 {
2256 return (void *)HW_OBJ_VRAM;
2257 }
2258
2259
2260 /*---------------------------------------------------------------------------*
2261 Name: G2S_GetOBJCharPtr
2262
2263 Description: Always returns (void*)HW_DB_OBJ_VRAM
2264
2265 Arguments: none
2266
2267 Returns: a pointer to the character data of OBJs
2268 *---------------------------------------------------------------------------*/
G2S_GetOBJCharPtr()2269 static inline void *G2S_GetOBJCharPtr()
2270 {
2271 return (void *)HW_DB_OBJ_VRAM;
2272 }
2273
2274
2275 #endif // SDK_FROM_TOOL
2276
2277 #ifdef __cplusplus
2278 }/* extern "C" */
2279 #endif
2280
2281 #endif
2282