ts-7000
[Top] [All Lists]

Re: [ts-7000] Kernal sees only 8MB of 32MB available RAM

To:
Subject: Re: [ts-7000] Kernal sees only 8MB of 32MB available RAM
From: Curtis Monroe <>
Date: Fri, 2 Sep 2005 17:51:45 -0400
ecos/packages/hal/arm/arm9/ts7250/current/include/plf_io.h

plf_io.h in redboot is responsible for creating a list of ATAG_MEM structs
describing the memory structure of the system for the kernel to use.

-Curtis.


#define CYGHWR_REDBOOT_LINUX_ATAG_MEM(_p_)                                      
               
\
    CYG_MACRO_START                                                             
               
\
    /* 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 = 0x800000;                                                 
                \
    _p_->u.mem.start = 0;                                                       
                                                        \
                                                                                
                                                                                
                                \
    _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 = 0x800000;                                                 
                \
    _p_->u.mem.start = 0x01000000;                                              
                                                \
                                                                                
                                                                                
                                \
    _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 = 0x800000;                                                 
                \
    _p_->u.mem.start = 0x04000000;                                              
\
                                                                                
                                                                                
                                \
    _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 = 0x800000;                                                 
                \
    _p_->u.mem.start = 0x05000000;                                              
\
                                                                                
                \
    if (ts7250_ram_present(0xc2000000)) { \
    _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 = 0x800000;                                                 
                \
    _p_->u.mem.start = 0xe0000000;                                              
                                                                        \
                                                                                
                                                                                
                                \
    _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 = 0x800000;                                                 
                \
    _p_->u.mem.start = 0xe1000000;                                              
                                                \
                                                                                
                                                                                
                                \
    _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 = 0x800000;                                                 
                \
    _p_->u.mem.start = 0xe4000000;                                              
\
                                                                                
                                                                                
                                \
    _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 = 0x800000;                                                 
                \
    _p_->u.mem.start = 0xe5000000;                                              
\
    } \
    CYG_MACRO_END
#endif // HAL_PLATFORM_TS7250



-Curtis.


On September 2, 2005 05:27 pm, genosensor wrote:
> When I compile the -ts8 kernel with the "standard" gcc 3.3.4,
>  it recognizes all banks of RAM.
>  However, when I try using my softfloat gcc 3.4 toolchain,
>  the resulting kernel sees only one bank of 8MB.
> 
>  Otherwise, it seems to function correctly.
> 
>  Anyone else out there run into anything like this?
> 
>  Can anyone tell me where to look in the kernel sources
>  for the code that probes memory banks?
> 
>  I'm assuming that something needs a "volatile" qualifier,
>  but it's just a guess.
> 
>  Thanks.
> 
> 
> 
> 
>   
>
> 
> SPONSORED LINKS
> Computer internet security   Linux os   Computer internet business
>   Computer internet access   Computer internet privacy securities   Computer
internet help
>
>   
> YAHOO! GROUPS LINKS
>
> 
>  Visit your group "ts-7000" on the web.
>  
>  To unsubscribe from this group, send an email to:
>  
>  
>  Your use of Yahoo! Groups is subject to the Yahoo! Terms of Service.
>
> 


------------------------ Yahoo! Groups Sponsor --------------------~-->
Most low income households are not online. Help bridge the digital divide today!
http://us.click.yahoo.com/cd_AJB/QnQLAA/TtwFAA/CFFolB/TM
--------------------------------------------------------------------~->


Yahoo! Groups Links

<*> To visit your group on the web, go to:
    http://groups.yahoo.com/group/ts-7000/

<*> To unsubscribe from this group, send an email to:
    

<*> Your use of Yahoo! Groups is subject to:
    http://docs.yahoo.com/info/terms/



<Prev in Thread] Current Thread [Next in Thread>
Admin

Disclaimer: Neither Andrew Taylor nor the University of NSW School of Computer and Engineering take any responsibility for the contents of this archive. It is purely a compilation of material sent by many people to the birding-aus mailing list. It has not been checked for accuracy nor its content verified in any way. If you wish to get material removed from the archive or have other queries about the archive e-mail Andrew Taylor at this address: andrewt@cse.unsw.EDU.AU