RedBoot TX53 Release 2012-02-15

[karo-tx-redboot.git] / packages / hal / arm / mx53 / karo / v1_0 / include / plf_io.h

diff --git a/packages/hal/arm/mx53/karo/v1_0/include/plf_io.h b/packages/hal/arm/mx53/karo/v1_0/include/plf_io.h
index 0b164f65d82a513554b008baf63c6c5d8e1632b2..4453514eb9ddb654d36d9b153418cfb29d904b55 100644 (file)
--- a/packages/hal/arm/mx53/karo/v1_0/include/plf_io.h
+++ b/packages/hal/arm/mx53/karo/v1_0/include/plf_io.h
@@ -45,25 +45,70 @@
 #include CYGBLD_HAL_PLF_DEFS_H
 #include <cyg/hal/hal_soc.h>
 
-#define CYGHWR_REDBOOT_LINUX_ATAG_MEM(_p_)                                                        \
-       CYG_MACRO_START                                                                            \
-       {                                                                                                  \
-         extern unsigned int system_rev;                                                                  \
-                        /* Next ATAG_MEM. */                                                              \
-                _p_->hdr.size = (sizeof(struct tag_mem32) + sizeof(struct tag_header))/sizeof(long);      \
-                _p_->hdr.tag = ATAG_MEM;                                                                  \
-                /* Round up so there's only one bit set in the memory size.                               \
-                * Don't double it if it's already a power of two, though.                                 \
-                */                                                                                        \
-                _p_->u.mem.size  = 1<<hal_msbindex(CYGMEM_REGION_ram_SIZE);                               \
-                if (_p_->u.mem.size < CYGMEM_REGION_ram_SIZE)                                             \
-                                _p_->u.mem.size <<= 1;                                                            \
-                _p_->u.mem.start = CYGARC_PHYSICAL_ADDRESS(CYGMEM_REGION_ram);                            \
-                _p_ = (struct tag *)((long *)_p_ + _p_->hdr.size);                                        \
-                _p_->hdr.size = ((sizeof(struct tag_revision)) + sizeof(struct tag_header))/sizeof(long); \
-                _p_->hdr.tag = ATAG_REVISION;                                                             \
-                _p_->u.revision.rev = system_rev;                                                         \
-       }                                                                                                  \
+#ifdef RAM_BANK1_SIZE
+#define CYGHWR_REDBOOT_LINUX_ATAG_MEM(_p_)                                                     \
+       CYG_MACRO_START                                                                                                 \
+       {                                                                                                                               \
+               extern unsigned int system_rev;                                                         \
+               /* Next ATAG_MEM. */                                                                            \
+               _p_->hdr.size = (sizeof(struct tag_mem32) +                                     \
+                                                 sizeof(struct tag_header))/sizeof(long);      \
+               _p_->hdr.tag = ATAG_MEM;                                                                        \
+               /* Round up so there's only one bit set in the memory size.     \
+               * Don't double it if it's already a power of two, though.       \
+               */                                                                                                                      \
+               _p_->u.mem.size  = 1<<hal_msbindex(RAM_BANK0_SIZE);                     \
+               if (_p_->u.mem.size < RAM_BANK0_SIZE)                                           \
+                                _p_->u.mem.size <<= 1;                                                         \
+               _p_->u.mem.start = RAM_BANK0_BASE;                                                      \
+                                                                                                                                       \
+               _p_ = (struct tag *)((long *)_p_ + _p_->hdr.size);                      \
+                                                                                                                                       \
+               /* Next ATAG_MEM. */                                                                            \
+               _p_->hdr.size = (sizeof(struct tag_mem32) +                                     \
+                                                 sizeof(struct tag_header))/sizeof(long);      \
+               _p_->hdr.tag = ATAG_MEM;                                                                        \
+               /* Round up so there's only one bit set in the memory size.     \
+               * Don't double it if it's already a power of two, though.       \
+               */                                                                                                                      \
+               _p_->u.mem.size  = 1<<hal_msbindex(RAM_BANK1_SIZE);                     \
+               if (_p_->u.mem.size < RAM_BANK1_SIZE)                                           \
+                                _p_->u.mem.size <<= 1;                                                         \
+               _p_->u.mem.start = RAM_BANK1_BASE;                                                      \
+                                                                                                                                       \
+               _p_ = (struct tag *)((long *)_p_ + _p_->hdr.size);                      \
+                                                                                                                                       \
+               _p_->hdr.size = ((sizeof(struct tag_revision)) +                        \
+                                                 sizeof(struct tag_header))/sizeof(long);      \
+               _p_->hdr.tag = ATAG_REVISION;                                                           \
+               _p_->u.revision.rev = system_rev;                                                       \
+       }                                                                                                                               \
        CYG_MACRO_END
+#else
+#define CYGHWR_REDBOOT_LINUX_ATAG_MEM(_p_)                                                     \
+       CYG_MACRO_START                                                                                                 \
+       {                                                                                                                               \
+               extern unsigned int system_rev;                                                         \
+               /* Next ATAG_MEM. */                                                                            \
+               _p_->hdr.size = (sizeof(struct tag_mem32) +                                     \
+                                                 sizeof(struct tag_header))/sizeof(long);      \
+               _p_->hdr.tag = ATAG_MEM;                                                                        \
+               /* Round up so there's only one bit set in the memory size.     \
+               * Don't double it if it's already a power of two, though.       \
+               */                                                                                                                      \
+               _p_->u.mem.size  = 1<<hal_msbindex(RAM_BANK0_SIZE);                     \
+               if (_p_->u.mem.size < RAM_BANK0_SIZE)                                           \
+                                _p_->u.mem.size <<= 1;                                                         \
+               _p_->u.mem.start = RAM_BANK0_BASE;                                                      \
+                                                                                                                                       \
+               _p_ = (struct tag *)((long *)_p_ + _p_->hdr.size);                      \
+                                                                                                                                       \
+               _p_->hdr.size = ((sizeof(struct tag_revision)) +                        \
+                                                 sizeof(struct tag_header))/sizeof(long);      \
+               _p_->hdr.tag = ATAG_REVISION;                                                           \
+               _p_->u.revision.rev = system_rev;                                                       \
+       }                                                                                                                               \
+       CYG_MACRO_END
+#endif /* RAM_BANK1_SIZE */
 
 #endif // CYGONCE_HAL_ARM_BOARD_PLF_IO_H