1 /*---------------------------------------------------------------------------*
2 Project: TwlSDK - GX -
3 File: gx.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-17#$
14 $Rev: 8556 $
15 $Author: okubata_ryoma $
16 *---------------------------------------------------------------------------*/
17
18 #ifndef NITRO_GX_GX_H_
19 #define NITRO_GX_GX_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_GXS.h>
25 #include <nitro/hw/common/mmap_shared.h>
26 #else
27 #include <twl/hw/ARM9/ioreg_GX.h>
28 #include <twl/hw/ARM9/ioreg_GXS.h>
29 #include <twl/hw/common/mmap_shared.h>
30 #endif
31
32 #if !(defined(SDK_WIN32) || defined(SDK_FROM_TOOL))
33 #include <nitro/mi.h>
34 #endif
35
36
37 #ifdef __cplusplus
38 extern "C" {
39 #endif
40
41 //----------------------------------------------------------------------------
42 // Type definition
43 //----------------------------------------------------------------------------
44
45 #define GX_LCD_SIZE_X 256
46 #define GX_LCD_SIZE_Y 192
47
48
49 //----------------------------------------------------------------------------
50 // Parameters for GX_SetGraphicsMode
51 //----------------------------------------------------------------------------
52 // Display control register(MAIN engine).
53 typedef union
54 {
55 u32 raw;
56 struct
57 {
58 u32 bgMode:3;
59 u32 bg0_2d3d:1;
60 u32 objMapChar:1;
61 u32 objMapBmp:2;
62 u32 blankScr:1;
63 u32 visiblePlane:5;
64 u32 visibleWnd:3;
65 u32 dispMode:4;
66 u32 extObjMapChar:2;
67 u32 extObjMapBmp:1;
68 u32 hBlankObjProc:1;
69 u32 bgCharOffset:3;
70 u32 bgScrOffset:3;
71 u32 bgExtPltt:1;
72 u32 objExtPltt:1;
73 };
74 }
75 GXDispCnt;
76
77 // Display control register(SUB engine).
78 typedef union
79 {
80 u32 raw;
81 struct
82 {
83 u32 bgMode:3;
84 u32 _reserve1:1;
85 u32 objMapChar:1;
86 u32 objMapBmp:2;
87 u32 blankScr:1;
88 u32 visiblePlane:5;
89 u32 visibleWnd:3;
90 u32 dispMode:1;
91 u32 _reserve2:3;
92 u32 extObjMapChar:2;
93 u32 _reserve3:1;
94 u32 hBlankObjProc:1;
95 u32 _reserve4:6;
96 u32 bgExtPltt:1;
97 u32 objExtPltt:1;
98 };
99 }
100 GXSDispCnt;
101
102
103 typedef enum
104 {
105 GX_BGMODE_0 = 0,
106 GX_BGMODE_1 = 1,
107 GX_BGMODE_2 = 2,
108 GX_BGMODE_3 = 3,
109 GX_BGMODE_4 = 4,
110 GX_BGMODE_5 = 5,
111 GX_BGMODE_6 = 6
112 }
113 GXBGMode;
114
115 #define GX_BGMODE_ASSERT(x) \
116 SDK_MINMAX_ASSERT(x, GX_BGMODE_0, GX_BGMODE_6)
117
118 typedef enum
119 {
120 GX_BG0_AS_2D = 0,
121 GX_BG0_AS_3D = 1
122 }
123 GXBG0As;
124
125 #define GX_BG0_AS_ASSERT(x) \
126 SDK_MINMAX_ASSERT(x, GX_BG0_AS_2D, GX_BG0_AS_3D)
127
128 typedef enum
129 {
130 GX_DISPMODE_GRAPHICS = 0x01,
131 GX_DISPMODE_VRAM_A = 0x02,
132 GX_DISPMODE_VRAM_B = 0x06,
133 GX_DISPMODE_VRAM_C = 0x0a,
134 GX_DISPMODE_VRAM_D = 0x0e,
135 GX_DISPMODE_MMEM = 0x03
136 }
137 GXDispMode;
138
139 // GX_DISPMODE_OFF is obsolete, use GX_DispOff instead.
140 #define GX_DISPMODE_OFF ((GXDispMode)0x00)
141
142 #define GX_DISPMODE_ASSERT(x) \
143 SDK_ASSERT( (x) == GX_DISPMODE_OFF || \
144 (x) == GX_DISPMODE_GRAPHICS || \
145 (x) == GX_DISPMODE_VRAM_A || \
146 (x) == GX_DISPMODE_VRAM_B || \
147 (x) == GX_DISPMODE_VRAM_C || \
148 (x) == GX_DISPMODE_VRAM_D || \
149 (x) == GX_DISPMODE_MMEM )
150
151 //----------------------------------------------------------------------------
152 // Parameters for GX_SetOBJVRamModeChar
153 //----------------------------------------------------------------------------
154 typedef enum
155 {
156 GX_OBJVRAMMODE_CHAR_2D = (0 << REG_GX_DISPCNT_OBJMAP_SHIFT) | (0 << REG_GX_DISPCNT_EXOBJ_SHIFT),
157 GX_OBJVRAMMODE_CHAR_1D_32K =
158 (1 << REG_GX_DISPCNT_OBJMAP_SHIFT) | (0 << REG_GX_DISPCNT_EXOBJ_SHIFT),
159 GX_OBJVRAMMODE_CHAR_1D_64K =
160 (1 << REG_GX_DISPCNT_OBJMAP_SHIFT) | (1 << REG_GX_DISPCNT_EXOBJ_SHIFT),
161 GX_OBJVRAMMODE_CHAR_1D_128K =
162 (1 << REG_GX_DISPCNT_OBJMAP_SHIFT) | (2 << REG_GX_DISPCNT_EXOBJ_SHIFT),
163 GX_OBJVRAMMODE_CHAR_1D_256K =
164 (1 << REG_GX_DISPCNT_OBJMAP_SHIFT) | (3 << REG_GX_DISPCNT_EXOBJ_SHIFT)
165 }
166 GXOBJVRamModeChar;
167
168 #define GX_OBJVRAMMODE_CHAR_ASSERT(x) \
169 SDK_ASSERT(x == GX_OBJVRAMMODE_CHAR_2D || \
170 x == GX_OBJVRAMMODE_CHAR_1D_32K || \
171 x == GX_OBJVRAMMODE_CHAR_1D_64K || \
172 x == GX_OBJVRAMMODE_CHAR_1D_128K || \
173 x == GX_OBJVRAMMODE_CHAR_1D_256K)
174
175 #define GXS_OBJVRAMMODE_CHAR_ASSERT(x) \
176 SDK_ASSERT(x == GX_OBJVRAMMODE_CHAR_2D || \
177 x == GX_OBJVRAMMODE_CHAR_1D_32K || \
178 x == GX_OBJVRAMMODE_CHAR_1D_64K || \
179 x == GX_OBJVRAMMODE_CHAR_1D_128K)
180
181
182 //----------------------------------------------------------------------------
183 // Parameters for GX_SetOBJVRamModeBmp
184 //----------------------------------------------------------------------------
185 typedef enum
186 {
187 GX_OBJVRAMMODE_BMP_2D_W128 =
188 (0 << (REG_GX_DISPCNT_OBJMAP_SHIFT + 1)) | (0 << (REG_GX_DISPCNT_EXOBJ_SHIFT + 2)),
189 GX_OBJVRAMMODE_BMP_2D_W256 =
190 (1 << (REG_GX_DISPCNT_OBJMAP_SHIFT + 1)) | (0 << (REG_GX_DISPCNT_EXOBJ_SHIFT + 2)),
191 GX_OBJVRAMMODE_BMP_1D_128K =
192 (2 << (REG_GX_DISPCNT_OBJMAP_SHIFT + 1)) | (0 << (REG_GX_DISPCNT_EXOBJ_SHIFT + 2)),
193 GX_OBJVRAMMODE_BMP_1D_256K =
194 (2 << (REG_GX_DISPCNT_OBJMAP_SHIFT + 1)) | (1 << (REG_GX_DISPCNT_EXOBJ_SHIFT + 2))
195 }
196 GXOBJVRamModeBmp;
197
198
199 // OBSOLETE: These macros will be removed in the future release.
200 #define GX_OBJVRAMMODE_BMP_2D_W128_32K GX_OBJVRAMMODE_BMP_2D_W128
201 #define GX_OBJVRAMMODE_BMP_2D_W256_32K GX_OBJVRAMMODE_BMP_2D_W256
202
203 #define GX_OBJVRAMMODE_BMP_ASSERT(x) \
204 SDK_ASSERT(x == GX_OBJVRAMMODE_BMP_2D_W128_32K || \
205 x == GX_OBJVRAMMODE_BMP_2D_W256_32K || \
206 x == GX_OBJVRAMMODE_BMP_1D_128K || \
207 x == GX_OBJVRAMMODE_BMP_1D_256K)
208
209 #define GXS_OBJVRAMMODE_BMP_ASSERT(x) \
210 SDK_ASSERT(x == GX_OBJVRAMMODE_BMP_2D_W128 || \
211 x == GX_OBJVRAMMODE_BMP_2D_W256 || \
212 x == GX_OBJVRAMMODE_BMP_1D_128K)
213
214 //----------------------------------------------------------------------------
215 // Parameters for GX_SetVisiblePlane
216 //----------------------------------------------------------------------------
217 typedef enum
218 {
219 GX_PLANEMASK_NONE = 0x00,
220 GX_PLANEMASK_BG0 = 0x01,
221 GX_PLANEMASK_BG1 = 0x02,
222 GX_PLANEMASK_BG2 = 0x04,
223 GX_PLANEMASK_BG3 = 0x08,
224 GX_PLANEMASK_OBJ = 0x10
225 }
226 GXPlaneMask;
227
228 #define GX_PLANEMASK_ASSERT(x) SDK_MINMAX_ASSERT(x, GX_PLANEMASK_NONE, 0x1f)
229
230 //----------------------------------------------------------------------------
231 // Parameters for GX_SetVisibleWnd
232 //----------------------------------------------------------------------------
233 typedef enum
234 {
235 GX_WNDMASK_NONE = 0x00,
236 GX_WNDMASK_W0 = 0x01,
237 GX_WNDMASK_W1 = 0x02,
238 GX_WNDMASK_OW = 0x04
239 }
240 GXWndMask;
241
242 #define GX_WNDMASK_ASSERT(x) SDK_MINMAX_ASSERT(x, GX_WNDMASK_NONE, 0x7)
243
244 //----------------------------------------------------------------------------
245 // Parameters for GX_SetBGCharOffset
246 //----------------------------------------------------------------------------
247 typedef enum
248 {
249 GX_BGCHAROFFSET_0x00000 = 0x00,
250 GX_BGCHAROFFSET_0x10000 = 0x01,
251 GX_BGCHAROFFSET_0x20000 = 0x02,
252 GX_BGCHAROFFSET_0x30000 = 0x03,
253 GX_BGCHAROFFSET_0x40000 = 0x04,
254 GX_BGCHAROFFSET_0x50000 = 0x05,
255 GX_BGCHAROFFSET_0x60000 = 0x06,
256 GX_BGCHAROFFSET_0x70000 = 0x07
257 }
258 GXBGCharOffset;
259
260 #define GX_BGCHAROFFSET_ASSERT(x) \
261 SDK_MINMAX_ASSERT(x, GX_BGCHAROFFSET_0x00000, GX_BGCHAROFFSET_0x70000)
262
263 //----------------------------------------------------------------------------
264 // Parameters for GX_SetBGScrOffset
265 //----------------------------------------------------------------------------
266 typedef enum
267 {
268 GX_BGSCROFFSET_0x00000 = 0x00,
269 GX_BGSCROFFSET_0x10000 = 0x01,
270 GX_BGSCROFFSET_0x20000 = 0x02,
271 GX_BGSCROFFSET_0x30000 = 0x03,
272 GX_BGSCROFFSET_0x40000 = 0x04,
273 GX_BGSCROFFSET_0x50000 = 0x05,
274 GX_BGSCROFFSET_0x60000 = 0x06,
275 GX_BGSCROFFSET_0x70000 = 0x07
276 }
277 GXBGScrOffset;
278
279 #define GX_BGSCROFFSET_ASSERT(x) \
280 SDK_MINMAX_ASSERT(x, GX_BGSCROFFSET_0x00000, GX_BGSCROFFSET_0x70000)
281
282 //----------------------------------------------------------------------------
283 // Parameters for GX_SetPower
284 //----------------------------------------------------------------------------
285 typedef enum
286 {
287 GX_POWER_OFF = 0,
288
289 GX_POWER_2D_MAIN = 1 << REG_GX_POWCNT_E2DG_SHIFT,
290 GX_POWER_2D_SUB = 1 << REG_GX_POWCNT_E2DGB_SHIFT,
291
292 GX_POWER_RE = 1 << REG_GX_POWCNT_RE_SHIFT,
293 GX_POWER_GE = 1 << REG_GX_POWCNT_GE_SHIFT,
294
295 GX_POWER_2D = GX_POWER_2D_MAIN | GX_POWER_2D_SUB,
296 GX_POWER_3D = GX_POWER_RE | GX_POWER_GE,
297
298 GX_POWER_ALL = GX_POWER_2D | GX_POWER_3D
299 /*
300 GX_POWER_LCD_TOP = 1 << REG_GX_POWCNT_LCD_SHIFT, // don't use. this is removed in near future.
301 GX_POWER_LCD_BOT = 1 << REG_GX_POWCNT_LCDB_SHIFT, // don't use. this is removed in near future.
302 GX_POWER_LCD = GX_POWER_LCD_TOP | GX_POWER_LCD_BOT // don't use. this is removed in near future.
303 */
304 }
305 GXPower;
306
307
308 #define GX_POWER_ASSERT(x) SDK_ASSERTMSG( ( ( (x) & ~GX_POWER_ALL ) == 0 ), \
309 "GX_POWER_LCD is obsolete. please use PM_SetLCDPower()\n" )
310
311 //----------------------------------------------------------------------------
312 // Parameters for GX_SetDispSelect, GX_GetDispSelect
313 //----------------------------------------------------------------------------
314 typedef enum
315 {
316 GX_DISP_SELECT_SUB_MAIN = 0,
317 GX_DISP_SELECT_MAIN_SUB = 1
318 }
319 GXDispSelect;
320
321 #define GX_DISP_SELECT_ASSERT(x) SDK_MINMAX_ASSERT(x, 0, 1)
322
323
324 /* if include from Other Environment for exsample VC or BCB, */
325 /* please define SDK_FROM_TOOL */
326 #if !(defined(SDK_WIN32) || defined(SDK_FROM_TOOL))
327
328 //----------------------------------------------------------------------------
329 // Declaration of function
330 //----------------------------------------------------------------------------
331
332 // reg_GX_POWCNT
333 static void GX_SetPower(int gxbit_power /* GXPower */ );
334 static GXPower GX_GetPower(void);
335
336 static void GX_Power2DMain(BOOL enable);
337 static void GX_Power2DSub(BOOL enable);
338
339 static void GX_PowerRender(BOOL enable);
340 static void GX_PowerGeometry(BOOL enable);
341
342 static void GXi_PowerLCD(BOOL enable);
343 static void GX_Power2D(BOOL enable);
344 static void GX_Power3D(BOOL enable);
345
346 static void GX_SetDispSelect(GXDispSelect sel);
347 static GXDispSelect GX_GetDispSelect(void);
348
349 // reg_GX_DISPSTAT
350 static s32 GX_IsHBlank(void);
351 s32 GX_HBlankIntr(BOOL enable);
352 static s32 GX_IsVBlank(void);
353 s32 GX_VBlankIntr(BOOL enable);
354 static s32 GX_IsVCountEq(void);
355 static void GX_VCountEqIntr(BOOL enable);
356 void GX_SetVCountEqVal(s32 val);
357 static s32 GX_GetVCountEqVal(void);
358
359 #define GX_IsVCounterEq GX_IsVCountEq
360 #define GX_VCounterEqIntr GX_VCountEqIntr
361 #define GX_SetVCounterEqVal GX_SetVCountEqVal
362 #define GX_GetVCounterEqVal GX_GetVCountEqVal
363
364 // reg_GX_VCOUNT
365 static s32 GX_GetVCount(void);
366 static void GX_SetVCount(s32 count);
367
368 void GX_Init(void);
369 static void GX_InitEx(u32 dma_no);
370 u32 GX_SetDefaultDMA(u32 dma_no);
371 static u32 GX_GetDefaultDMA(void);
372 #ifdef SDK_TWL
373 u32 GX_SetDefaultNDMA(u32 ndma_no);
374 static u32 GX_GetDefaultNDMA(void);
375 #endif
376
377 //
378 // Main 2D engine
379 //
380
381 // reg_GX_DISPCNT
382 void GX_SetGraphicsMode(GXDispMode dispMode, GXBGMode bgMode, GXBG0As bg0_2d3d);
383 void GX_DispOff(void);
384 void GX_DispOn(void);
385 BOOL GX_IsDispOn(void);
386
387 static void GX_SetVisiblePlane(int plane /* GXPlaneMask */ );
388 static void GX_SetVisibleWnd(int window /* GXWndMask */ );
389 static void GX_BlankScr(BOOL blank);
390
391 static GXBGScrOffset GX_GetBGScrOffset();
392 static void GX_SetBGScrOffset(GXBGScrOffset offset);
393
394 static GXBGCharOffset GX_GetBGCharOffset();
395 static void GX_SetBGCharOffset(GXBGCharOffset offset);
396
397 static void GX_SetOBJVRamModeChar(GXOBJVRamModeChar mode);
398 static void GX_SetOBJVRamModeBmp(GXOBJVRamModeBmp mode);
399
400 static void GX_HBlankOBJProc(BOOL proc);
401
402 // reg_GX_MASTER_BRIGHT
403 static void GX_SetMasterBrightness(int brightness);
404
405 //
406 // Sub 2D engine
407 //
408
409 void GXS_SetGraphicsMode(GXBGMode bgMode);
410 static void GXS_DispOff(void);
411 static void GXS_DispOn(void);
412
413 static void GXS_SetVisiblePlane(int plane /* GXPlaneMask */ );
414 static void GXS_SetVisibleWnd(int window /* GXWndMask */ );
415
416 static void GXS_SetOBJVRamModeChar(GXOBJVRamModeChar mode);
417 static void GXS_SetOBJVRamModeBmp(GXOBJVRamModeBmp mode);
418
419 static void GXS_HBlankOBJProc(BOOL proc);
420
421 static void GXS_SetMasterBrightness(int brightness);
422
423 //
424 // Internal use
425 //
426 void GXx_SetMasterBrightness_(vu16 *reg, int brightness);
427 int GXx_GetMasterBrightness_(vu16 *reg);
428
429 //----------------------------------------------------------------------------
430 // Implementation of inline function
431 //----------------------------------------------------------------------------
432
433 /*---------------------------------------------------------------------------*
434 Name: GX_GetBGMode
435
436 Description: Gets the BG mode(MAIN engine).
437
438 Arguments: none
439
440 Returns: BG mode
441 *---------------------------------------------------------------------------*/
GX_GetDispCnt(void)442 static inline GXDispCnt GX_GetDispCnt(void)
443 {
444 return *(volatile GXDispCnt *)REG_DISPCNT_ADDR;
445 }
446
447
448 /*---------------------------------------------------------------------------*
449 Name: GXS_GetBGMode
450
451 Description: Gets the BG mode(MAIN engine).
452
453 Arguments: none
454
455 Returns: BG mode
456 *---------------------------------------------------------------------------*/
GXS_GetDispCnt(void)457 static inline GXSDispCnt GXS_GetDispCnt(void)
458 {
459 return *(volatile GXSDispCnt *)REG_DB_DISPCNT_ADDR;
460 }
461
462
463 /*---------------------------------------------------------------------------*
464 Name: GX_GetBGScrOffset
465
466 Description: Gets the screen offset of BGs.
467
468 Arguments: none
469
470 Returns: Screen offset of BGs
471 *---------------------------------------------------------------------------*/
GX_GetBGScrOffset()472 static inline GXBGScrOffset GX_GetBGScrOffset()
473 {
474 return (GXBGScrOffset)((reg_GX_DISPCNT & REG_GX_DISPCNT_BGSCREENOFFSET_MASK) >>
475 REG_GX_DISPCNT_BGSCREENOFFSET_SHIFT);
476 }
477
478
479 /*---------------------------------------------------------------------------*
480 Name: GX_SetBGScrOffset
481
482 Description: Specifies the screen offset of BGs.
483
484 Arguments: offset Screen offset of BGs
485
486 Returns: none
487 *---------------------------------------------------------------------------*/
GX_SetBGScrOffset(GXBGScrOffset offset)488 static inline void GX_SetBGScrOffset(GXBGScrOffset offset)
489 {
490 GX_BGSCROFFSET_ASSERT(offset);
491 reg_GX_DISPCNT = (u32)((reg_GX_DISPCNT & ~REG_GX_DISPCNT_BGSCREENOFFSET_MASK) |
492 (offset << REG_GX_DISPCNT_BGSCREENOFFSET_SHIFT));
493 }
494
495
496 /*---------------------------------------------------------------------------*
497 Name: GX_GetBGCharOffset
498
499 Description: Gets the character offset of BGs.
500
501 Arguments: none
502
503 Returns: Character offset of BGs
504 *---------------------------------------------------------------------------*/
GX_GetBGCharOffset()505 static inline GXBGCharOffset GX_GetBGCharOffset()
506 {
507 return (GXBGCharOffset)((reg_GX_DISPCNT & REG_GX_DISPCNT_BGCHAROFFSET_MASK)
508 >> REG_GX_DISPCNT_BGCHAROFFSET_SHIFT);
509 }
510
511
512 /*---------------------------------------------------------------------------*
513 Name: GX_SetBGCharOffset
514
515 Description: Specifies the character offset of BGs.
516
517 Arguments: offset Character offset of BGs
518
519 Returns: none
520 *---------------------------------------------------------------------------*/
GX_SetBGCharOffset(GXBGCharOffset offset)521 static inline void GX_SetBGCharOffset(GXBGCharOffset offset)
522 {
523 GX_BGCHAROFFSET_ASSERT(offset);
524 reg_GX_DISPCNT = (u32)((reg_GX_DISPCNT & ~REG_GX_DISPCNT_BGCHAROFFSET_MASK) |
525 (offset << REG_GX_DISPCNT_BGCHAROFFSET_SHIFT));
526 }
527
528
529 /*---------------------------------------------------------------------------*
530 Name: GX_SetVisiblePlane
531
532 Description: Specifies the planes to be visible(MAIN engine).
533
534 Arguments: plane set of visible planes
535
536 Returns: none
537 *---------------------------------------------------------------------------*/
GX_SetVisiblePlane(int plane)538 static inline void GX_SetVisiblePlane(int plane)
539 {
540 GX_PLANEMASK_ASSERT(plane);
541
542 reg_GX_DISPCNT = (u32)((reg_GX_DISPCNT & ~REG_GX_DISPCNT_DISPLAY_MASK) |
543 (plane << REG_GX_DISPCNT_DISPLAY_SHIFT));
544 }
545
546 /*---------------------------------------------------------------------------*
547 Name: GX_GetVisiblePlane
548
549 Description: Get the visible planes (MAIN engine).
550
551 Arguments: none
552
553 Returns: set of visible planes
554 *---------------------------------------------------------------------------*/
GX_GetVisiblePlane(void)555 static inline int GX_GetVisiblePlane(void)
556 {
557 return (int)((reg_GX_DISPCNT & REG_GX_DISPCNT_DISPLAY_MASK) >> REG_GX_DISPCNT_DISPLAY_SHIFT);
558 }
559
560 /*---------------------------------------------------------------------------*
561 Name: GXS_SetVisiblePlane
562
563 Description: Specifies the planes to be visible(SUB engine).
564
565 Arguments: plane set of visible planes
566
567 Returns: none
568 *---------------------------------------------------------------------------*/
GXS_SetVisiblePlane(int plane)569 static inline void GXS_SetVisiblePlane(int plane)
570 {
571 GX_PLANEMASK_ASSERT(plane);
572
573 reg_GXS_DB_DISPCNT = (u32)((reg_GXS_DB_DISPCNT & ~REG_GXS_DB_DISPCNT_DISPLAY_MASK) |
574 (plane << REG_GXS_DB_DISPCNT_DISPLAY_SHIFT));
575 }
576
577 /*---------------------------------------------------------------------------*
578 Name: GXS_GetVisiblePlane
579
580 Description: Get the visible planes(SUB engine).
581
582 Arguments: none
583
584 Returns: set of visible planes
585 *---------------------------------------------------------------------------*/
GXS_GetVisiblePlane(void)586 static inline int GXS_GetVisiblePlane(void)
587 {
588 return (int)((reg_GXS_DB_DISPCNT & REG_GXS_DB_DISPCNT_DISPLAY_MASK)
589 >> REG_GXS_DB_DISPCNT_DISPLAY_SHIFT);
590 }
591
592
593 /*---------------------------------------------------------------------------*
594 Name: GX_SetVisibleWnd
595
596 Description: Specifies the windows to be visible(MAIN engine).
597
598 Arguments: plane set of visible windows
599
600 Returns: none
601 *---------------------------------------------------------------------------*/
GX_SetVisibleWnd(int window)602 static inline void GX_SetVisibleWnd(int window)
603 {
604 GX_WNDMASK_ASSERT(window);
605
606 reg_GX_DISPCNT = (u32)((reg_GX_DISPCNT &
607 ~(REG_GX_DISPCNT_W0_MASK |
608 REG_GX_DISPCNT_W1_MASK |
609 REG_GX_DISPCNT_OW_MASK)) | (window << REG_GX_DISPCNT_W0_SHIFT));
610 }
611
612 /*---------------------------------------------------------------------------*
613 Name: GX_GetVisibleWnd
614
615 Description: Get the visible windows(MAIN engine).
616
617 Arguments: none.
618
619 Returns: set of visible windows
620 *---------------------------------------------------------------------------*/
GX_GetVisibleWnd(void)621 static inline int GX_GetVisibleWnd(void)
622 {
623 return (int)((reg_GX_DISPCNT & (REG_GX_DISPCNT_W0_MASK |
624 REG_GX_DISPCNT_W1_MASK |
625 REG_GX_DISPCNT_OW_MASK)) >> REG_GX_DISPCNT_W0_SHIFT);
626 }
627
628
629 /*---------------------------------------------------------------------------*
630 Name: GXS_SetVisibleWnd
631
632 Description: Specifies the windows to be visible(SUB engine).
633
634 Arguments: plane set of visible windows
635
636 Returns: none
637 *---------------------------------------------------------------------------*/
GXS_SetVisibleWnd(int window)638 static inline void GXS_SetVisibleWnd(int window)
639 {
640 GX_WNDMASK_ASSERT(window);
641
642 reg_GXS_DB_DISPCNT = (u32)((reg_GXS_DB_DISPCNT &
643 ~(REG_GXS_DB_DISPCNT_W0_MASK |
644 REG_GXS_DB_DISPCNT_W1_MASK |
645 REG_GXS_DB_DISPCNT_OW_MASK)) |
646 (window << REG_GXS_DB_DISPCNT_W0_SHIFT));
647 }
648
649 /*---------------------------------------------------------------------------*
650 Name: GXS_GetVisibleWnd
651
652 Description: Get the visible windows(SUB engine).
653
654 Arguments: none.
655
656 Returns: set of visible windows
657 *---------------------------------------------------------------------------*/
GXS_GetVisibleWnd(void)658 static inline int GXS_GetVisibleWnd(void)
659 {
660 return (int)((reg_GXS_DB_DISPCNT & (REG_GXS_DB_DISPCNT_W0_MASK |
661 REG_GXS_DB_DISPCNT_W1_MASK |
662 REG_GXS_DB_DISPCNT_OW_MASK))
663 >> REG_GXS_DB_DISPCNT_W0_SHIFT);
664 }
665
666
667
668 /*---------------------------------------------------------------------------*
669 Name: GX_SetOBJVRamModeChar
670
671 Description: Specifies the condition for OBJ-VRAM(ChrOBJ) (MAIN engine).
672
673 Arguments: mode select the size and the mapping mode for Character Object
674
675 Returns: none
676 *---------------------------------------------------------------------------*/
GX_SetOBJVRamModeChar(GXOBJVRamModeChar mode)677 static inline void GX_SetOBJVRamModeChar(GXOBJVRamModeChar mode)
678 {
679 GX_OBJVRAMMODE_CHAR_ASSERT(mode);
680
681 reg_GX_DISPCNT = (u32)(reg_GX_DISPCNT &
682 ~(REG_GX_DISPCNT_EXOBJ_CH_MASK | REG_GX_DISPCNT_OBJMAP_CH_MASK) | mode);
683 }
684
685 /*---------------------------------------------------------------------------*
686 Name: GX_GetOBJVRamModeChar
687
688 Description: Get the condition for OBJ-VRAM(ChrOBJ) (MAIN engine).
689
690 Arguments: none.
691
692 Returns: select the size and the mapping mode for Character Object
693 *---------------------------------------------------------------------------*/
GX_GetOBJVRamModeChar(void)694 static inline GXOBJVRamModeChar GX_GetOBJVRamModeChar(void)
695 {
696 return (GXOBJVRamModeChar)(reg_GX_DISPCNT &
697 (REG_GX_DISPCNT_EXOBJ_CH_MASK | REG_GX_DISPCNT_OBJMAP_CH_MASK));
698 }
699
700
701 /*---------------------------------------------------------------------------*
702 Name: GXS_SetOBJVRamModeChar
703
704 Description: Specifies the condition for OBJ-VRAM(ChrOBJ) (SUB engine).
705
706 Arguments: mode select the size and the mapping mode for Character Object
707
708 Returns: none
709 *---------------------------------------------------------------------------*/
GXS_SetOBJVRamModeChar(GXOBJVRamModeChar mode)710 static inline void GXS_SetOBJVRamModeChar(GXOBJVRamModeChar mode)
711 {
712 GXS_OBJVRAMMODE_CHAR_ASSERT(mode);
713
714 reg_GXS_DB_DISPCNT = (u32)(reg_GXS_DB_DISPCNT &
715 ~(REG_GXS_DB_DISPCNT_EXOBJ_CH_MASK |
716 REG_GXS_DB_DISPCNT_OBJMAP_CH_MASK) | mode);
717 }
718
719 /*---------------------------------------------------------------------------*
720 Name: GXS_GetOBJVRamModeChar
721
722 Description: Get the condition for OBJ-VRAM(ChrOBJ) (SUB engine).
723
724 Arguments: none.
725
726 Returns: select the size and the mapping mode for Character Object
727 *---------------------------------------------------------------------------*/
GXS_GetOBJVRamModeChar(void)728 static inline GXOBJVRamModeChar GXS_GetOBJVRamModeChar(void)
729 {
730 return (GXOBJVRamModeChar)(reg_GXS_DB_DISPCNT &
731 (REG_GXS_DB_DISPCNT_EXOBJ_CH_MASK |
732 REG_GXS_DB_DISPCNT_OBJMAP_CH_MASK));
733 }
734
735
736 /*---------------------------------------------------------------------------*
737 Name: GX_SetOBJVRamModeBmp
738
739 Description: Specifies the condition for OBJ-VRAM(BitmapOBJ) (MAIN engine).
740
741 Arguments: mode select the size and the mapping mode for Bitmap Object
742
743 Returns: none
744 *---------------------------------------------------------------------------*/
GX_SetOBJVRamModeBmp(GXOBJVRamModeBmp mode)745 static inline void GX_SetOBJVRamModeBmp(GXOBJVRamModeBmp mode)
746 {
747 GX_OBJVRAMMODE_BMP_ASSERT(mode);
748
749 reg_GX_DISPCNT = (u32)(reg_GX_DISPCNT &
750 ~(REG_GX_DISPCNT_EXOBJ_BM_MASK | REG_GX_DISPCNT_OBJMAP_BM_MASK) | mode);
751 }
752
753
754 /*---------------------------------------------------------------------------*
755 Name: GX_GetOBJVRamModeBmp
756
757 Description: Get the condition for OBJ-VRAM(BitmapOBJ) (MAIN engine).
758
759 Arguments: none.
760
761 Returns: select the size and the mapping mode for Bitmap Object
762 *---------------------------------------------------------------------------*/
GX_GetOBJVRamModeBmp(void)763 static inline GXOBJVRamModeBmp GX_GetOBJVRamModeBmp(void)
764 {
765 return (GXOBJVRamModeBmp)(reg_GX_DISPCNT &
766 (REG_GX_DISPCNT_EXOBJ_BM_MASK | REG_GX_DISPCNT_OBJMAP_BM_MASK));
767 }
768
769
770 /*---------------------------------------------------------------------------*
771 Name: GXS_SetOBJVRamModeBmp
772
773 Description: Specifies the condition for OBJ-VRAM(BitmapOBJ) (SUB engine).
774
775 Arguments: mode select the size and the mapping mode for Bitmap Object
776
777 Returns: none
778 *---------------------------------------------------------------------------*/
GXS_SetOBJVRamModeBmp(GXOBJVRamModeBmp mode)779 static inline void GXS_SetOBJVRamModeBmp(GXOBJVRamModeBmp mode)
780 {
781 GXS_OBJVRAMMODE_BMP_ASSERT(mode);
782
783 reg_GXS_DB_DISPCNT = (u32)(reg_GXS_DB_DISPCNT & ~(REG_GXS_DB_DISPCNT_OBJMAP_BM_MASK) | mode);
784 }
785
786
787 /*---------------------------------------------------------------------------*
788 Name: GXS_GetOBJVRamModeBmp
789
790 Description: Get the condition for OBJ-VRAM(BitmapOBJ) (SUB engine).
791
792 Arguments: none.
793
794 Returns: select the size and the mapping mode for Bitmap Object
795 *---------------------------------------------------------------------------*/
GXS_GetOBJVRamModeBmp(void)796 static inline GXOBJVRamModeBmp GXS_GetOBJVRamModeBmp(void)
797 {
798 return (GXOBJVRamModeBmp)(reg_GXS_DB_DISPCNT & REG_GXS_DB_DISPCNT_OBJMAP_BM_MASK);
799 }
800
801
802 /*---------------------------------------------------------------------------*
803 Name: GX_BlankScr
804
805 Description: Stops the MAIN 2D circuit.
806 ******** THIS WILL BE REMOVED IN THE FUTURE RELEASE. ********
807 ******** USE GX_DispOn/GX_DispOff INSTEAD. ********
808
809 Arguments: blank if FALSE, displays.
810 otherwise: the 2D graphics circuit doesn't access on VRAM,
811 LCD becomes white.
812
813 Returns: none
814 *---------------------------------------------------------------------------*/
GX_BlankScr(BOOL blank)815 static inline void GX_BlankScr(BOOL blank)
816 {
817 SDK_WARNING((1 == 0), "GX_BlankScr is obsolete, please use GX_DispOn/GX_DispOff instead.");
818 if (blank)
819 {
820 reg_GX_DISPCNT |= REG_GX_DISPCNT_BLANK_MASK;
821 }
822 else
823 {
824 reg_GX_DISPCNT &= ~REG_GX_DISPCNT_BLANK_MASK;
825 }
826 }
827
828
829 /*---------------------------------------------------------------------------*
830 Name: GXS_DispOff
831
832 Description: Stops displaying the output of the SUB engine.
833
834 Arguments: none
835
836 Returns: none
837 *---------------------------------------------------------------------------*/
GXS_DispOff(void)838 static inline void GXS_DispOff(void)
839 {
840 reg_GXS_DB_DISPCNT &= ~REG_GXS_DB_DISPCNT_MODE_MASK;
841 }
842
843
844 /*---------------------------------------------------------------------------*
845 Name: GXS_DispOn
846
847 Description: Starts displaying the output of the SUB engine.
848
849 Arguments: none
850
851 Returns: none
852 *---------------------------------------------------------------------------*/
GXS_DispOn(void)853 static inline void GXS_DispOn(void)
854 {
855 reg_GXS_DB_DISPCNT |= REG_GXS_DB_DISPCNT_MODE_MASK;
856 }
857
858
859 /*---------------------------------------------------------------------------*
860 Name: GX_HBlankOBJProc
861
862 Description: if FALSE, do not process OBJ during H-Blank.
863 otherwise, process OBJ even during H-Blank(MAIN engine).
864
865 Arguments: proc FALSE / not FALSE(TRUE)
866
867 Returns: none
868 *---------------------------------------------------------------------------*/
GX_HBlankOBJProc(BOOL proc)869 static inline void GX_HBlankOBJProc(BOOL proc)
870 {
871 if (proc)
872 {
873 reg_GX_DISPCNT |= REG_GX_DISPCNT_OH_MASK;
874 }
875 else
876 {
877 reg_GX_DISPCNT &= ~REG_GX_DISPCNT_OH_MASK;
878 }
879 }
880
881
882 /*---------------------------------------------------------------------------*
883 Name: GXS_HBlankOBJProc
884
885 Description: if FALSE, do not process OBJ during H-Blank.
886 otherwise, process OBJ even during H-Blank(SUB engine).
887
888 Arguments: proc FALSE / not FALSE(TRUE)
889
890 Returns: none
891 *---------------------------------------------------------------------------*/
GXS_HBlankOBJProc(BOOL proc)892 static inline void GXS_HBlankOBJProc(BOOL proc)
893 {
894 if (proc)
895 {
896 reg_GXS_DB_DISPCNT |= REG_GXS_DB_DISPCNT_OH_MASK;
897 }
898 else
899 {
900 reg_GXS_DB_DISPCNT &= ~REG_GXS_DB_DISPCNT_OH_MASK;
901 }
902 }
903
904
905 /*---------------------------------------------------------------------------*
906 Name: GX_SetMasterBrightness
907
908 Description: Set master brightness(MAIN engine).
909
910 Arguments: brightness master brightness control(-16 to 16)
911
912 Returns: none
913 *---------------------------------------------------------------------------*/
GX_SetMasterBrightness(int brightness)914 static inline void GX_SetMasterBrightness(int brightness)
915 {
916 GXx_SetMasterBrightness_(®_GX_MASTER_BRIGHT, brightness);
917 }
918
919 /*---------------------------------------------------------------------------*
920 Name: GX_GetMasterBrightness
921
922 Description: Get master brightness(MAIN engine).
923
924 Arguments: none.
925
926 Returns: master brightness control(-16 to 16)
927 *---------------------------------------------------------------------------*/
GX_GetMasterBrightness(void)928 static inline int GX_GetMasterBrightness(void)
929 {
930 return GXx_GetMasterBrightness_(®_GX_MASTER_BRIGHT);
931 }
932
933
934 /*---------------------------------------------------------------------------*
935 Name: GXS_SetMasterBrightness
936
937 Description: Set master brightness(SUB engine).
938
939 Arguments: brightness master brightness control(-16 to 16)
940
941 Returns: none
942 *---------------------------------------------------------------------------*/
GXS_SetMasterBrightness(int brightness)943 static inline void GXS_SetMasterBrightness(int brightness)
944 {
945 GXx_SetMasterBrightness_(®_GXS_DB_MASTER_BRIGHT, brightness);
946 }
947
948 /*---------------------------------------------------------------------------*
949 Name: GXS_GetMasterBrightness
950
951 Description: Get master brightness(SUB engine).
952
953 Arguments: none.
954
955 Returns: master brightness control(-16 to 16)
956 *---------------------------------------------------------------------------*/
GXS_GetMasterBrightness(void)957 static inline int GXS_GetMasterBrightness(void)
958 {
959 return GXx_GetMasterBrightness_(®_GXS_DB_MASTER_BRIGHT);
960 }
961
962
963 /*---------------------------------------------------------------------------*
964 Name: GX_IsHBlank
965
966 Description: Tests if H-Blank.
967
968 Arguments: none
969
970 Returns: 0 if not in H-Blank
971 otherwise if in H-Blank
972 *---------------------------------------------------------------------------*/
GX_IsHBlank(void)973 static inline s32 GX_IsHBlank(void)
974 {
975 return (reg_GX_DISPSTAT & REG_GX_DISPSTAT_HBLK_MASK);
976 }
977
978
979 /*---------------------------------------------------------------------------*
980 Name: GX_IsVBlank
981
982 Description: Tests if V-Blank.
983
984 Arguments: none
985
986 Returns: 0 if not in V-Blank
987 otherwise if in V-Blank
988 *---------------------------------------------------------------------------*/
GX_IsVBlank(void)989 static inline s32 GX_IsVBlank(void)
990 {
991 return (reg_GX_DISPSTAT & REG_GX_DISPSTAT_VBLK_MASK);
992 }
993
994
995 /*---------------------------------------------------------------------------*
996 Name: GX_IsVCountEq
997
998 Description: Tests if VCount is equal to GX_VCountEqVal().
999
1000 Arguments: none
1001
1002 Returns: 0 if V-counter not equal to GX_VCountEqVal()
1003 otherwise if V-counter equal to GX_VCountEqVal()
1004 *---------------------------------------------------------------------------*/
GX_IsVCountEq(void)1005 static inline s32 GX_IsVCountEq(void)
1006 {
1007 return (reg_GX_DISPSTAT & REG_GX_DISPSTAT_LYC_MASK);
1008 }
1009
1010
1011 /*---------------------------------------------------------------------------*
1012 Name: GX_VCountEqIntr
1013
1014 Description: Enable/disable V-Counter equality interrupt.
1015
1016 Arguments: enable FALSE / not FALSE(TRUE)
1017
1018 Returns: None
1019 *---------------------------------------------------------------------------*/
GX_VCountEqIntr(BOOL enable)1020 static inline void GX_VCountEqIntr(BOOL enable)
1021 {
1022 if (enable)
1023 {
1024 reg_GX_DISPSTAT |= REG_GX_DISPSTAT_VQI_MASK;
1025 }
1026 else
1027 {
1028 reg_GX_DISPSTAT &= ~REG_GX_DISPSTAT_VQI_MASK;
1029 }
1030 }
1031
1032
1033 /*---------------------------------------------------------------------------*
1034 Name: GX_GetVCount
1035
1036 Description: Obtain the value of the current VCOUNTER register.
1037
1038 Arguments: none
1039
1040 Returns: the value of the current VCOUNTER register
1041 *---------------------------------------------------------------------------*/
GX_GetVCount()1042 static inline s32 GX_GetVCount()
1043 {
1044 return reg_GX_VCOUNT;
1045 }
1046
1047
1048 /*---------------------------------------------------------------------------*
1049 Name: GX_SetVCount
1050
1051 Description: Sets the value of the current VCOUNTER register.
1052
1053 Arguments: count the value to be new VCOUNTER
1054
1055 Returns: none
1056 *---------------------------------------------------------------------------*/
GX_SetVCount(s32 count)1057 static inline void GX_SetVCount(s32 count)
1058 {
1059 static vu32 vblank_count;
1060
1061 if(count < 202 || count > 211)
1062 {
1063 SDK_TFATAL_ERROR("V Counter out of range(%d). it must be 202 to 211.", count);
1064 }
1065 else if(vblank_count == *(vu32 *)HW_VBLANK_COUNT_BUF)
1066 {
1067 SDK_TFATAL_ERROR("Set V Count once a frame.");
1068 }
1069 else
1070 {
1071 OSIntrMode intr_mode;
1072 s32 current_count;
1073
1074 intr_mode = OS_DisableInterrupts();
1075 current_count = reg_GX_VCOUNT;
1076
1077 // accept (current_count == 211)
1078 if(current_count < 202 || current_count > 211)
1079 {
1080 SDK_TFATAL_ERROR("Current V Counter out of range(%d). it must be 202 to 211.", current_count);
1081 }
1082 else if(count > current_count)
1083 {
1084 SDK_TFATAL_ERROR("Cannot advance the V Counter");
1085 }
1086 else
1087 {
1088 reg_GX_VCOUNT = (u16)count;
1089 vblank_count = *(vu32 *)HW_VBLANK_COUNT_BUF;
1090 }
1091
1092 (void)OS_RestoreInterrupts(intr_mode);
1093 }
1094 }
1095
1096 /*---------------------------------------------------------------------------*
1097 Name: GX_GetVCountEqVal
1098
1099 Description: Get the V-counter agreement value.
1100
1101 Arguments: None
1102
1103 Returns: the value of V-counter to interrupt
1104 *---------------------------------------------------------------------------*/
GX_GetVCountEqVal(void)1105 static inline s32 GX_GetVCountEqVal(void)
1106 {
1107 u16 val = reg_GX_DISPSTAT;
1108 return ((val >> 8) & 0x00ff) | ((val << 1) & 0x0100);
1109 }
1110
1111 /*---------------------------------------------------------------------------*
1112 Name: GX_SetPower
1113
1114 Description: Power Control
1115
1116 Arguments: gxbit_power specifies the modules to be enabled
1117
1118 Returns: none
1119 *---------------------------------------------------------------------------*/
GX_SetPower(int gxbit_power)1120 static inline void GX_SetPower(int gxbit_power)
1121 {
1122 GX_POWER_ASSERT(gxbit_power);
1123
1124 reg_GX_POWCNT = (u16)((reg_GX_POWCNT & ~GX_POWER_ALL) | gxbit_power);
1125 }
1126
1127
1128 /*---------------------------------------------------------------------------*
1129 Name: GX_GetPower
1130
1131 Description: Gets the state of power control.
1132
1133 Arguments: none
1134
1135 Returns: the state of power control
1136 *---------------------------------------------------------------------------*/
GX_GetPower()1137 static inline GXPower GX_GetPower()
1138 {
1139 return (GXPower)(reg_GX_POWCNT & GX_POWER_ALL);
1140 }
1141
1142
1143 /*---------------------------------------------------------------------------*
1144 Name: GXi_PowerLCD
1145
1146 Description: Controls the power of LCDs.
1147
1148 Arguments: enable if FALSE, LCDs are off.
1149 otherwise, LCDs are on.
1150
1151 Returns: none
1152 *---------------------------------------------------------------------------*/
GXi_PowerLCD(BOOL enable)1153 static inline void GXi_PowerLCD(BOOL enable)
1154 {
1155 if (enable)
1156 {
1157 reg_GX_POWCNT |= REG_GX_POWCNT_LCD_MASK;
1158 }
1159 else
1160 {
1161 reg_GX_POWCNT &= ~REG_GX_POWCNT_LCD_MASK;
1162 }
1163 }
1164
1165
1166 /*---------------------------------------------------------------------------*
1167 removed function. if thies functions used, rise errer at compile.
1168 *---------------------------------------------------------------------------*/
1169 // #define SDK_ERR() macro does not exist. It's for notify of modification.
1170 #define GX_PowerLCD(x) SDK_ERR("GX_PowerLCD() is discontinued. please use PM_SetLCDPower()\n")
1171 #define GX_PowerLCDTop(x) SDK_ERR("GX_PowerLCDTop() is discontinued. please use PM_SetLCDPower()\n")
1172 #define GX_PowerLCDBot(x) SDK_ERR("GX_PowerLCDBot() is discontinued. please use PM_SetLCDPower()\n")
1173 #define GX_POWER_LCD_TOP SDK_ERR("GX_POWER_LCD_TOP is discontinued. please use PM_SetLCDPower()\n")
1174 #define GX_POWER_LCD_BOT SDK_ERR("GX_POWER_LCD_BOT is discontinued. please use PM_SetLCDPower()\n")
1175 #define GX_POWER_LCD SDK_ERR("GX_POWER_LCD is discontinued. please use PM_SetLCDPower()\n")
1176
1177
1178 /*---------------------------------------------------------------------------*
1179 Name: GX_Power2D
1180
1181 Description: Controls the power of the 2D Graphics Engines.
1182
1183 Arguments: enable if FALSE, the 2D engines are off.
1184 otherwise, the 2D engines are on.
1185
1186 Returns: none
1187 *---------------------------------------------------------------------------*/
GX_Power2D(BOOL enable)1188 static inline void GX_Power2D(BOOL enable)
1189 {
1190 if (enable)
1191 {
1192 reg_GX_POWCNT |= (REG_GX_POWCNT_E2DG_MASK | REG_GX_POWCNT_E2DGB_MASK);
1193 }
1194 else
1195 {
1196 reg_GX_POWCNT &= ~(REG_GX_POWCNT_E2DG_MASK | REG_GX_POWCNT_E2DGB_MASK);
1197 }
1198 }
1199
1200
1201 /*---------------------------------------------------------------------------*
1202 Name: GX_Power2DMain
1203
1204 Description: Controls the power of the main 2D Graphics Engine.
1205
1206 Arguments: enable if FALSE, the main 2D engine is off.
1207 otherwise, the main 2D engine is on.
1208
1209 Returns: none
1210 *---------------------------------------------------------------------------*/
GX_Power2DMain(BOOL enable)1211 static inline void GX_Power2DMain(BOOL enable)
1212 {
1213 if (enable)
1214 {
1215 reg_GX_POWCNT |= REG_GX_POWCNT_E2DG_MASK;
1216 }
1217 else
1218 {
1219 reg_GX_POWCNT &= ~REG_GX_POWCNT_E2DG_MASK;
1220 }
1221 }
1222
1223
1224 /*---------------------------------------------------------------------------*
1225 Name: GX_Power2DSub
1226
1227 Description: Controls the power of the sub 2D Graphics Engine.
1228
1229 Arguments: enable if FALSE, the sub 2D engine is off.
1230 otherwise, the sub 2D engine is on.
1231
1232 Returns: none
1233 *---------------------------------------------------------------------------*/
GX_Power2DSub(BOOL enable)1234 static inline void GX_Power2DSub(BOOL enable)
1235 {
1236 if (enable)
1237 {
1238 reg_GX_POWCNT |= REG_GX_POWCNT_E2DGB_MASK;
1239 }
1240 else
1241 {
1242 reg_GX_POWCNT &= ~REG_GX_POWCNT_E2DGB_MASK;
1243 }
1244 }
1245
1246
1247 /*---------------------------------------------------------------------------*
1248 Name: GX_PowerRender
1249
1250 Description: Power Control of the Rendering Engine.
1251
1252 Arguments: enable if FALSE, the rendering engine is off.
1253 otherwise, the rendering engine is on.
1254
1255 Returns: none
1256 *---------------------------------------------------------------------------*/
GX_PowerRender(BOOL enable)1257 static inline void GX_PowerRender(BOOL enable)
1258 {
1259 if (enable)
1260 {
1261 reg_GX_POWCNT |= REG_GX_POWCNT_RE_MASK;
1262 }
1263 else
1264 {
1265 reg_GX_POWCNT &= ~REG_GX_POWCNT_RE_MASK;
1266 }
1267 }
1268
1269
1270 /*---------------------------------------------------------------------------*
1271 Name: GX_PowerGeometry
1272
1273 Description: Power Control of the Geometry Engine.
1274
1275 Arguments: enable if FALSE, the geometry engine is off.
1276 otherwise, the geometry engine is on.
1277
1278 Returns: none
1279 *---------------------------------------------------------------------------*/
GX_PowerGeometry(BOOL enable)1280 static inline void GX_PowerGeometry(BOOL enable)
1281 {
1282 if (enable)
1283 {
1284 reg_GX_POWCNT |= REG_GX_POWCNT_GE_MASK;
1285 }
1286 else
1287 {
1288 reg_GX_POWCNT &= ~REG_GX_POWCNT_GE_MASK;
1289 }
1290 }
1291
1292
1293 /*---------------------------------------------------------------------------*
1294 Name: GX_Power3D
1295
1296 Description: Power Control of the Geometry and Rendering Engine.
1297
1298 Arguments: enable if FALSE, the engines are off.
1299 otherwise, the engines are on.
1300
1301 Returns: none
1302 *---------------------------------------------------------------------------*/
GX_Power3D(BOOL enable)1303 static inline void GX_Power3D(BOOL enable)
1304 {
1305 if (enable)
1306 {
1307 reg_GX_POWCNT |= (REG_GX_POWCNT_GE_MASK | REG_GX_POWCNT_RE_MASK);
1308 }
1309 else
1310 {
1311 reg_GX_POWCNT &= ~(REG_GX_POWCNT_GE_MASK | REG_GX_POWCNT_RE_MASK);
1312 }
1313 }
1314
1315
1316 /*---------------------------------------------------------------------------*
1317 Name: GX_SetDispSelect
1318
1319 Description: Selects the LCDs to output.
1320
1321 Arguments: sel TOP/main BOT/sub if GX_DISP_SELECT_MAIN_SUB
1322 TOP/sub BOT/main if GX_DISP_SELECT_SUB_MAIN
1323 Returns: none
1324 *---------------------------------------------------------------------------*/
GX_SetDispSelect(GXDispSelect sel)1325 static inline void GX_SetDispSelect(GXDispSelect sel)
1326 {
1327 GX_DISP_SELECT_ASSERT(sel);
1328
1329 reg_GX_POWCNT = (u16)((reg_GX_POWCNT & ~REG_GX_POWCNT_DSEL_MASK) |
1330 (sel << REG_GX_POWCNT_DSEL_SHIFT));
1331 }
1332
1333
1334 /*---------------------------------------------------------------------------*
1335 Name: GX_GetDispSelect
1336
1337 Description: Gets the output switch set by GX_SetDispSelect.
1338
1339 Arguments: none
1340
1341 Returns: GX_DISP_SELECT_MAIN_SUB or GX_DISP_SELECT_SUB_MAIN
1342 *---------------------------------------------------------------------------*/
GX_GetDispSelect(void)1343 static inline GXDispSelect GX_GetDispSelect(void)
1344 {
1345 return (GXDispSelect)((reg_GX_POWCNT & REG_GX_POWCNT_DSEL_MASK) >> REG_GX_POWCNT_DSEL_SHIFT);
1346 }
1347
1348
1349 /*---------------------------------------------------------------------------*
1350 Name: GX_InitEx
1351
1352 Description: Initializes the registers for graphics(except 3D)
1353 with set default dmaNo.
1354
1355 Arguments: none
1356
1357 Returns: none
1358 *---------------------------------------------------------------------------*/
GX_InitEx(u32 dma_no)1359 static inline void GX_InitEx(u32 dma_no)
1360 {
1361 SDK_ASSERT(dma_no <= MI_DMA_MAX_NUM || dma_no == GX_DMA_NOT_USE);
1362
1363 GXi_DmaId = dma_no;
1364 GX_Init();
1365 }
1366
1367 /*---------------------------------------------------------------------------*
1368 Name: GX_GetDefaultDMA
1369
1370 Description: get default DMA channel.
1371
1372 Arguments: none.
1373
1374 Returns: current DMA channel.
1375 *---------------------------------------------------------------------------*/
GX_GetDefaultDMA(void)1376 static inline u32 GX_GetDefaultDMA(void)
1377 {
1378 if (GXi_DmaId > 3)
1379 {
1380 return GX_DMA_NOT_USE;
1381 }
1382 return GXi_DmaId;
1383 }
1384
1385 /*---------------------------------------------------------------------------*
1386 Name: GX_GetDefaultNDMA
1387
1388 Description: get default NDMA channel.
1389
1390 Arguments: none.
1391
1392 Returns: current NDMA channel.
1393 *---------------------------------------------------------------------------*/
1394 #ifdef SDK_TWL
GX_GetDefaultNDMA(void)1395 static inline u32 GX_GetDefaultNDMA(void)
1396 {
1397 if (GXi_DmaId > 3)
1398 {
1399 return (GXi_DmaId - 4);
1400 }
1401 return GX_DMA_NOT_USE;
1402 }
1403 #endif
1404
1405 #endif // SDK_FROM_TOOL
1406
1407 #ifdef __cplusplus
1408 }/* extern "C" */
1409 #endif
1410
1411 /* NITRO_GX_GX_H_ */
1412 #endif
1413