1 /*---------------------------------------------------------------------------*
2   Project:  TwlSDK - GX -
3   File:     gx_bgcnt.c
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 #include <nitro/gx/gx_bgcnt.h>
19 #include <nitro/gx/gx.h>
20 
21 //
22 // Internal use
23 //
getBGScreenOffset_(void)24 static inline int getBGScreenOffset_(void)
25 {
26     return (int)(0x10000 * ((reg_GX_DISPCNT & REG_GX_DISPCNT_BGSCREENOFFSET_MASK) >>
27                             REG_GX_DISPCNT_BGSCREENOFFSET_SHIFT));
28 }
29 
getBGCharOffset_(void)30 static inline int getBGCharOffset_(void)
31 {
32     return (int)(0x10000 * ((reg_GX_DISPCNT & REG_GX_DISPCNT_BGCHAROFFSET_MASK) >>
33                             REG_GX_DISPCNT_BGCHAROFFSET_SHIFT));
34 }
35 
36 
37 /*---------------------------------------------------------------------------*
38   Name:         G2_GetBG0ScrPtr
39 
40   Description:  Returns a pointer to BG #0 screen(MAIN engine).
41 
42   Arguments:    none
43 
44   Returns:      a pointer to BG #0 screen
45  *---------------------------------------------------------------------------*/
G2_GetBG0ScrPtr(void)46 void   *G2_GetBG0ScrPtr(void)
47 {
48     int     baseBlock = 0x800 * ((reg_G2_BG0CNT & REG_G2_BG0CNT_SCREENBASE_MASK) >>
49                                  REG_G2_BG0CNT_SCREENBASE_SHIFT);
50 
51     return (void *)(HW_BG_VRAM + getBGScreenOffset_() + baseBlock);
52 }
53 
54 
55 /*---------------------------------------------------------------------------*
56   Name:         G2S_GetBG0ScrPtr
57 
58   Description:  Returns a pointer to BG #0 screen(SUB engine).
59 
60   Arguments:    none
61 
62   Returns:      a pointer to BG #0 screen
63  *---------------------------------------------------------------------------*/
G2S_GetBG0ScrPtr(void)64 void   *G2S_GetBG0ScrPtr(void)
65 {
66     int     baseBlock = 0x800 * ((reg_G2S_DB_BG0CNT & REG_G2S_DB_BG0CNT_SCREENBASE_MASK) >>
67                                  REG_G2S_DB_BG0CNT_SCREENBASE_SHIFT);
68 
69     return (void *)(HW_DB_BG_VRAM + baseBlock);
70 }
71 
72 
73 /*---------------------------------------------------------------------------*
74   Name:         G2_GetBG1ScrPtr
75 
76   Description:  Returns a pointer to BG #1 screen(MAIN engine).
77 
78   Arguments:    none
79 
80   Returns:      a pointer to BG #1 screen
81  *---------------------------------------------------------------------------*/
G2_GetBG1ScrPtr(void)82 void   *G2_GetBG1ScrPtr(void)
83 {
84     int     baseBlock = 0x800 * ((reg_G2_BG1CNT & REG_G2_BG1CNT_SCREENBASE_MASK) >>
85                                  REG_G2_BG1CNT_SCREENBASE_SHIFT);
86 
87     return (void *)(HW_BG_VRAM + getBGScreenOffset_() + baseBlock);
88 }
89 
90 
91 /*---------------------------------------------------------------------------*
92   Name:         G2S_GetBG1ScrPtr
93 
94   Description:  Returns a pointer to BG #1 screen(SUB engine).
95 
96   Arguments:    none
97 
98   Returns:      a pointer to BG #1 screen
99  *---------------------------------------------------------------------------*/
G2S_GetBG1ScrPtr(void)100 void   *G2S_GetBG1ScrPtr(void)
101 {
102     int     baseBlock = 0x800 * ((reg_G2S_DB_BG1CNT & REG_G2S_DB_BG1CNT_SCREENBASE_MASK)
103                                  >> REG_G2S_DB_BG1CNT_SCREENBASE_SHIFT);
104 
105     return (void *)(HW_DB_BG_VRAM + baseBlock);
106 }
107 
108 
109 /*---------------------------------------------------------------------------*
110   Name:         G2_GetBG2ScrPtr
111 
112   Description:  Returns a pointer to BG #2 screen(MAIN engine).
113 
114   Arguments:    none
115 
116   Returns:      a pointer to BG #2 screen,
117                 NULL if BGMODE is GX_BGMODE_6.
118  *---------------------------------------------------------------------------*/
119 #include <nitro/code32.h>              // ARM binary is even better in size.
G2_GetBG2ScrPtr(void)120 void   *G2_GetBG2ScrPtr(void)
121 {
122     GXBGMode bgMode = (GXBGMode)((reg_GX_DISPCNT & REG_GX_DISPCNT_BGMODE_MASK) >>
123                                  REG_GX_DISPCNT_BGMODE_SHIFT);
124     u32     bg = reg_G2_BG2CNT;
125     int     offset = getBGScreenOffset_();
126     u32     blockID = (bg & REG_G2_BG2CNT_SCREENBASE_MASK) >> REG_G2_BG2CNT_SCREENBASE_SHIFT;
127 
128     switch (bgMode)
129     {
130     case GX_BGMODE_0:
131     case GX_BGMODE_1:
132     case GX_BGMODE_2:
133     case GX_BGMODE_3:
134     case GX_BGMODE_4:
135         // Text or SR BG
136         return (void *)(HW_BG_VRAM + offset + 0x800 * blockID);
137         break;
138     case GX_BGMODE_5:
139         // Extended SR BG
140         if (bg & REG_G2_BG2CNT_COLORMODE_MASK)
141         {
142             // Bitmap BG
143             return (void *)(HW_BG_VRAM + 0x4000 * blockID);
144         }
145         else
146         {
147             // Char BG
148             return (void *)(HW_BG_VRAM + offset + 0x800 * blockID);
149         }
150         break;
151     case GX_BGMODE_6:
152         // 256 colors large bitmap screen
153         return (void *)HW_BG_VRAM;
154         break;
155     default:
156         SDK_INTERNAL_ERROR("unknown BGMODE 0x%x", bgMode);
157         return NULL;
158         break;
159     }
160 }
161 
162 #include <nitro/codereset.h>
163 
164 
165 /*---------------------------------------------------------------------------*
166   Name:         G2S_GetBG2ScrPtr
167 
168   Description:  Returns a pointer to BG #2 screen(SUB engine).
169 
170   Arguments:    none
171 
172   Returns:      a pointer to BG #2 screen,
173                 NULL if BGMODE is GX_BGMODE_6.
174  *---------------------------------------------------------------------------*/
G2S_GetBG2ScrPtr(void)175 void   *G2S_GetBG2ScrPtr(void)
176 {
177     GXBGMode bgMode = (GXBGMode)((reg_GXS_DB_DISPCNT & REG_GXS_DB_DISPCNT_BGMODE_MASK) >>
178                                  REG_GXS_DB_DISPCNT_BGMODE_SHIFT);
179     u32     bg = reg_G2S_DB_BG2CNT;
180     u32     blockID =
181         (bg & REG_G2S_DB_BG2CNT_SCREENBASE_MASK) >> REG_G2S_DB_BG2CNT_SCREENBASE_SHIFT;
182 
183     switch (bgMode)
184     {
185     case GX_BGMODE_0:
186     case GX_BGMODE_1:
187     case GX_BGMODE_2:
188     case GX_BGMODE_3:
189     case GX_BGMODE_4:
190         // Text or SR BG
191         return (void *)(HW_DB_BG_VRAM + 0x800 * blockID);
192         break;
193     case GX_BGMODE_5:
194         // Extended SR BG
195         if (bg & REG_G2S_DB_BG2CNT_COLORMODE_MASK)
196         {
197             // Bitmap BG
198             return (void *)(HW_DB_BG_VRAM + 0x4000 * blockID);
199         }
200         else
201         {
202             // Char BG
203             return (void *)(HW_DB_BG_VRAM + 0x800 * blockID);
204         }
205         break;
206     case GX_BGMODE_6:
207         return NULL;
208         break;
209     default:
210         SDK_INTERNAL_ERROR("unknown BGMODE 0x%x", bgMode);
211         return NULL;
212         break;
213     }
214 }
215 
216 
217 /*---------------------------------------------------------------------------*
218   Name:         G2_GetBG3ScrPtr
219 
220   Description:  Returns a pointer to BG #3 screen(MAIN engine).
221 
222   Arguments:    none
223 
224   Returns:      a pointer to BG #3 screen,
225                 NULL if BGMODE is GX_BGMODE_6.
226  *---------------------------------------------------------------------------*/
227 #include <nitro/code32.h>              // ARM binary is even better in size.
G2_GetBG3ScrPtr(void)228 void   *G2_GetBG3ScrPtr(void)
229 {
230     GXBGMode bgMode = (GXBGMode)((reg_GX_DISPCNT & REG_GX_DISPCNT_BGMODE_MASK) >>
231                                  REG_GX_DISPCNT_BGMODE_SHIFT);
232     u32     bg = reg_G2_BG3CNT;
233     int     offset = getBGScreenOffset_();
234     u32     blockID = (bg & REG_G2_BG3CNT_SCREENBASE_MASK) >> REG_G2_BG3CNT_SCREENBASE_SHIFT;
235 
236     switch (bgMode)
237     {
238     case GX_BGMODE_0:
239     case GX_BGMODE_1:
240     case GX_BGMODE_2:
241         // Text or affine BG
242         return (void *)(HW_BG_VRAM + offset + 0x800 * blockID);
243         break;
244     case GX_BGMODE_3:
245     case GX_BGMODE_4:
246     case GX_BGMODE_5:
247         // Extended affine BG
248         if (bg & REG_G2_BG3CNT_COLORMODE_MASK)
249         {
250             // Bitmap BG
251             return (void *)(HW_BG_VRAM + 0x4000 * blockID);
252         }
253         else
254         {
255             // Char BG
256             return (void *)(HW_BG_VRAM + offset + 0x800 * blockID);
257         }
258         break;
259     case GX_BGMODE_6:
260         return NULL;
261         break;
262     default:
263         SDK_INTERNAL_ERROR("unknown BGMODE 0x%x", bgMode);
264         return NULL;
265         break;
266     }
267 }
268 
269 #include <nitro/codereset.h>
270 
271 
272 /*---------------------------------------------------------------------------*
273   Name:         G2S_GetBG3ScrPtr
274 
275   Description:  Returns a pointer to BG #3 screen(SUB engine).
276 
277   Arguments:    none
278 
279   Returns:      a pointer to BG #3 screen,
280                 NULL if BGMODE is GX_BGMODE_6.
281  *---------------------------------------------------------------------------*/
G2S_GetBG3ScrPtr(void)282 void   *G2S_GetBG3ScrPtr(void)
283 {
284     GXBGMode bgMode = (GXBGMode)((reg_GXS_DB_DISPCNT & REG_GXS_DB_DISPCNT_BGMODE_MASK) >>
285                                  REG_GXS_DB_DISPCNT_BGMODE_SHIFT);
286     u32     bg = reg_G2S_DB_BG3CNT;
287     u32     blockID =
288         (bg & REG_G2S_DB_BG3CNT_SCREENBASE_MASK) >> REG_G2S_DB_BG3CNT_SCREENBASE_SHIFT;
289 
290     switch (bgMode)
291     {
292     case GX_BGMODE_0:
293     case GX_BGMODE_1:
294     case GX_BGMODE_2:
295         // Text or affine BG
296         return (void *)(HW_DB_BG_VRAM + 0x800 * blockID);
297         break;
298     case GX_BGMODE_3:
299     case GX_BGMODE_4:
300     case GX_BGMODE_5:
301         // Extended affine BG
302         if (bg & REG_G2S_DB_BG3CNT_COLORMODE_MASK)
303         {
304             // Bitmap BG
305             return (void *)(HW_DB_BG_VRAM + 0x4000 * blockID);
306         }
307         else
308         {
309             // Char BG
310             return (void *)(HW_DB_BG_VRAM + 0x800 * blockID);
311         }
312         break;
313     case GX_BGMODE_6:
314         return NULL;
315         break;
316     default:
317         SDK_INTERNAL_ERROR("unknown BGMODE 0x%x", bgMode);
318         return NULL;
319         break;
320     }
321 }
322 
323 
324 // CharPtr
325 /*---------------------------------------------------------------------------*
326   Name:         G2_GetBG0CharPtr
327 
328   Description:  Returns a pointer to BG #0 character(MAIN engine).
329 
330   Arguments:    none
331 
332   Returns:      a pointer to BG #0 character
333  *---------------------------------------------------------------------------*/
G2_GetBG0CharPtr(void)334 void   *G2_GetBG0CharPtr(void)
335 {
336     int     baseBlock = 0x4000 * ((reg_G2_BG0CNT & REG_G2_BG0CNT_CHARBASE_MASK) >>
337                                   REG_G2_BG0CNT_CHARBASE_SHIFT);
338 
339     return (void *)(HW_BG_VRAM + getBGCharOffset_() + baseBlock);
340 }
341 
342 
343 /*---------------------------------------------------------------------------*
344   Name:         G2S_GetBG0CharPtr
345 
346   Description:  Returns a pointer to BG #0 character(SUB engine).
347 
348   Arguments:    none
349 
350   Returns:      a pointer to BG #0 character
351  *---------------------------------------------------------------------------*/
G2S_GetBG0CharPtr(void)352 void   *G2S_GetBG0CharPtr(void)
353 {
354     int     baseBlock = 0x4000 * ((reg_G2S_DB_BG0CNT & REG_G2S_DB_BG0CNT_CHARBASE_MASK) >>
355                                   REG_G2S_DB_BG0CNT_CHARBASE_SHIFT);
356 
357     return (void *)(HW_DB_BG_VRAM + baseBlock);
358 }
359 
360 
361 /*---------------------------------------------------------------------------*
362   Name:         G2_GetBG1CharPtr
363 
364   Description:  Returns a pointer to BG #1 character(MAIN engine).
365 
366   Arguments:    none
367 
368   Returns:      a pointer to BG #1 character
369  *---------------------------------------------------------------------------*/
G2_GetBG1CharPtr(void)370 void   *G2_GetBG1CharPtr(void)
371 {
372     int     baseBlock = 0x4000 * ((reg_G2_BG1CNT & REG_G2_BG1CNT_CHARBASE_MASK) >>
373                                   REG_G2_BG1CNT_CHARBASE_SHIFT);
374 
375     return (void *)(HW_BG_VRAM + getBGCharOffset_() + baseBlock);
376 }
377 
378 
379 /*---------------------------------------------------------------------------*
380   Name:         G2S_GetBG1CharPtr
381 
382   Description:  Returns a pointer to BG #1 character(SUB engine).
383 
384   Arguments:    none
385 
386   Returns:      a pointer to BG #1 character
387  *---------------------------------------------------------------------------*/
G2S_GetBG1CharPtr(void)388 void   *G2S_GetBG1CharPtr(void)
389 {
390     int     baseBlock = 0x4000 * ((reg_G2S_DB_BG1CNT & REG_G2S_DB_BG1CNT_CHARBASE_MASK) >>
391                                   REG_G2S_DB_BG1CNT_CHARBASE_SHIFT);
392 
393     return (void *)(HW_DB_BG_VRAM + baseBlock);
394 }
395 
396 
397 /*---------------------------------------------------------------------------*
398   Name:         G2_GetBG2CharPtr
399 
400   Description:  Returns a pointer to BG #2 character(MAIN engine).
401 
402   Arguments:    none
403 
404   Returns:      BG #2 is character BG:     a pointer to BG #2 character
405                 otherwise:                 NULL
406  *---------------------------------------------------------------------------*/
G2_GetBG2CharPtr(void)407 void   *G2_GetBG2CharPtr(void)
408 {
409     GXBGMode bgMode = (GXBGMode)((reg_GX_DISPCNT & REG_GX_DISPCNT_BGMODE_MASK) >>
410                                  REG_GX_DISPCNT_BGMODE_SHIFT);
411     u32     bg = reg_G2_BG2CNT;
412 
413     if (bgMode < 5 || !(bg & REG_G2_BG2CNT_COLORMODE_MASK))
414     {
415         // Text BG, affine BG, or extended affine character BG
416         int     offset = getBGCharOffset_();
417         u32     blockID = (bg & REG_G2_BG2CNT_CHARBASE_MASK) >> REG_G2_BG2CNT_CHARBASE_SHIFT;
418 
419         return (void *)(HW_BG_VRAM + offset + 0x4000 * blockID);
420     }
421     else
422     {
423         // otherwise
424         return NULL;
425     }
426 }
427 
428 
429 /*---------------------------------------------------------------------------*
430   Name:         G2S_GetBG2CharPtr
431 
432   Description:  Returns a pointer to BG #2 character(SUB engine).
433 
434   Arguments:    none
435 
436   Returns:      BG #2 is character BG:     a pointer to BG #2 character
437                 otherwise:                 NULL
438  *---------------------------------------------------------------------------*/
G2S_GetBG2CharPtr(void)439 void   *G2S_GetBG2CharPtr(void)
440 {
441     GXBGMode bgMode = (GXBGMode)((reg_GXS_DB_DISPCNT & REG_GXS_DB_DISPCNT_BGMODE_MASK) >>
442                                  REG_GXS_DB_DISPCNT_BGMODE_SHIFT);
443     u32     bg = reg_G2S_DB_BG2CNT;
444     if (bgMode < 5 || !(bg & REG_G2S_DB_BG2CNT_COLORMODE_MASK))
445     {
446         // Text BG, affine BG, or extended affine character BG
447         u32     blockID =
448             (bg & REG_G2S_DB_BG2CNT_CHARBASE_MASK) >> REG_G2S_DB_BG2CNT_CHARBASE_SHIFT;
449 
450         return (void *)(HW_DB_BG_VRAM + 0x4000 * blockID);
451     }
452     else
453     {
454         // otherwise
455         return NULL;
456     }
457 }
458 
459 
460 /*---------------------------------------------------------------------------*
461   Name:         G2_GetBG3CharPtr
462 
463   Description:  Returns a pointer to BG #3 character(MAIN engine).
464 
465   Arguments:    none
466 
467   Returns:      BG #3 is character BG:     a pointer to BG #3 character
468                 otherwise:                 NULL
469  *---------------------------------------------------------------------------*/
G2_GetBG3CharPtr(void)470 void   *G2_GetBG3CharPtr(void)
471 {
472     GXBGMode bgMode = (GXBGMode)((reg_GX_DISPCNT & REG_GX_DISPCNT_BGMODE_MASK) >>
473                                  REG_GX_DISPCNT_BGMODE_SHIFT);
474     u32     bg = reg_G2_BG3CNT;
475     if (bgMode < 3 || (bgMode < 6 && !(bg & REG_G2_BG2CNT_COLORMODE_MASK)))
476     {
477         // Text BG, affine BG, or extended affine character BG
478         u32     blockID = (bg & REG_G2_BG3CNT_CHARBASE_MASK) >> REG_G2_BG3CNT_CHARBASE_SHIFT;
479         int     offset = getBGCharOffset_();
480 
481         return (void *)(HW_BG_VRAM + offset + 0x4000 * blockID);
482     }
483     else
484     {
485         // otherwise
486         return NULL;
487     }
488 }
489 
490 
491 /*---------------------------------------------------------------------------*
492   Name:         G2S_GetBG3CharPtr
493 
494   Description:  Returns a pointer to BG #3 character(SUB engine).
495 
496   Arguments:    none
497 
498   Returns:      BG #3 is character BG:     a pointer to BG #3 character
499                 otherwise:                 NULL
500  *---------------------------------------------------------------------------*/
G2S_GetBG3CharPtr(void)501 void   *G2S_GetBG3CharPtr(void)
502 {
503     GXBGMode bgMode = (GXBGMode)((reg_GXS_DB_DISPCNT & REG_GXS_DB_DISPCNT_BGMODE_MASK) >>
504                                  REG_GXS_DB_DISPCNT_BGMODE_SHIFT);
505     u32     bg = reg_G2S_DB_BG3CNT;
506     if (bgMode < 3 || (bgMode < 6 && !(bg & REG_G2S_DB_BG2CNT_COLORMODE_MASK)))
507     {
508         // Text BG, affine BG, or extended affine character BG
509         u32     blockID =
510             (bg & REG_G2S_DB_BG3CNT_CHARBASE_MASK) >> REG_G2S_DB_BG3CNT_CHARBASE_SHIFT;
511 
512         return (void *)(HW_DB_BG_VRAM + 0x4000 * blockID);
513     }
514     else
515     {
516         // otherwise
517         return NULL;
518     }
519 }
520