ssp_page.c

abstract rtos

#ifdef	__cplusplus
extern "C"{
#endif

#include "syscfg.h"

#if (AOS_INCLUDE_SSP_PAGE == TRUE)

#include "aos.h"

#undef PAGE_DEBUG
#define PAGE_MAGIC  0xFF000001


#if( CONFIG_BOARD_EIA == TRUE )
struct sta_page_buf
{
    U8* start_addr;
    U8* end_addr;
};

extern U32 web_task_id;
extern U8 web_page_start[],web_page_end[];
#ifdef _EIA2000V3
extern U8 dsp_prog_start[],dsp_prog_end[];
#endif
extern VOID dsp_disable_program();
extern VOID web_disable_page();
extern VOID web_prog_start();
extern VOID web_prog_end();


struct sta_page_buf g_StaPageBuf[] = 
{
#ifdef _EIA2000V3    
   { dsp_prog_start, &dsp_prog_end[4] },
#endif    
   { web_page_start, &web_page_end[4] },
   { (U8*)web_prog_start, (U8*)web_prog_end }
};

#endif

page_t *aos_page_new( MPE mpe )
{
    page_t *page;
    U32    blk_no;
#if( CONFIG_BOARD_EIA == TRUE )
    U8*    new_blk;
    U32    buf_id;
#endif
    U32    max_blk_num;

    if( MPE_LOAD == mpe )
    {
        max_blk_num = 384; 
    }
    else
    {
        max_blk_num = PAGE_DEFAULT_BLK_NUM;
    }

    page = aos_dmem_alloc( mpe, SID_PAGE_HEAD, sizeof(page_t) + sizeof(U8*) * (max_blk_num-1) );
    if( page )
    {
        page->magic_num = PAGE_MAGIC;
        page->mpe       = mpe;
        page->opt       = 0;
        page->sum       = 0;
        page->page_size = 0;
        page->blk_size  = PAGE_DEFAULT_BLK_SIZE;
        page->blk_num   = 0;
        page->read_ptr  = 0;
        page->write_ptr = 0;
        page->max_blk_num = max_blk_num;

        for( blk_no = 0; blk_no < page->max_blk_num; blk_no++ )
        {
            page->blk_ptr[blk_no] = NULL;
        }

        page->ext_mem_ptr = NULL;
        page->ext_mem_size = 0;
        
#if( CONFIG_BOARD_EIA == TRUE )
        if( MPE_LOAD == mpe )
        {
#ifdef _EIA2000V3            
            dsp_disable_program();
#endif
            
            if( web_task_id != aos_task_self() )
            {
                web_disable_page();
            }
            
            for( buf_id = 0; buf_id < sizeof(g_StaPageBuf)/sizeof(struct sta_page_buf);buf_id++ )
            {
                new_blk = g_StaPageBuf[buf_id].start_addr;
                while( (new_blk + page->blk_size) <= g_StaPageBuf[buf_id].end_addr )
                {
                    page->blk_ptr[page->blk_num++] = new_blk;
                    new_blk += page->blk_size;
                }
            }
            
            aos_printf( 0, "Initial load block(4K) num is %u", page->blk_num  );
        }
#endif            
    }

#ifdef PAGE_DEBUG
    aos_printf( 0, "new page,mpe=%u, page=0x%x", mpe, page );
#endif

    return page;
}

VOID aos_page_delete( page_t *page )
{
    U32 blk_no;

#ifdef PAGE_DEBUG
    aos_printf( 0, "page delete,mpe=%u", page->mpe );
#endif

    if( page && ( PAGE_MAGIC == page->magic_num ) )
    {
        for( blk_no = 0; blk_no < page->blk_num; blk_no++ )
        {
            if( page->blk_ptr[blk_no] )
            {
                aos_dmem_free( page->blk_ptr[blk_no] );
            }
        }

        page->magic_num = 0;
        page->page_size = 0;
        page->blk_size  = 0;
        page->blk_num   = 0;
        page->read_ptr  = 0;
        page->write_ptr = 0;

        aos_dmem_free( page );
    }
    else
    {
        AOS_ASSERT_FUNC( 0, aos_printf( 0, "page invalid,page=0x%x", page ) );
    }
}


U32 aos_page_read( page_t *page, U8 *buf, U32 len )
{
    U32 read_len;
    
    if( !page || (PAGE_MAGIC != page->magic_num) )
    {
        AOS_ASSERT( 0 );
        return 0;
    }


    read_len = aos_page_read_off( page, page->read_ptr, buf, len );
    page->read_ptr += read_len;

    return read_len;
}


U32 aos_page_read_off( page_t *page, U32 off, U8 *buf, U32 len )
{
    U32 blk_no, off_in_blk, len_in_blk, ret_len;
    
    if( !page || (PAGE_MAGIC != page->magic_num) )
    {
        AOS_ASSERT( 0 );        
        return 0;
    }

    if( off >= page->page_size )
    {
        return 0;
    }

    if( len > ( page->page_size - off ) )
    {
        len = page->page_size - off;
    }
    ret_len = len;

    
    if( off < page->ext_mem_size )
    {
        len_in_blk = page->ext_mem_size - off;
        if( len_in_blk >= len )
        {
            aos_memcpy( buf, page->ext_mem_ptr + off, len );
            return len;
        }
        aos_memcpy( buf, page->ext_mem_ptr + off, len_in_blk );
        off = 0;
        buf += len_in_blk;
        len -= len_in_blk;
    }
    else
    {
        off -= page->ext_mem_size;
    }

    for( ;; )
    {
        blk_no     = off / page->blk_size;
        off_in_blk = off % page->blk_size;
        len_in_blk = page->blk_size - off_in_blk;

        if( len_in_blk >= len )
        {
            aos_memcpy( buf, &page->blk_ptr[blk_no][off_in_blk], len );
            break;
        }
        else
        {
            aos_memcpy( buf, &page->blk_ptr[blk_no][off_in_blk], len_in_blk );
            len -= len_in_blk;
            off += len_in_blk;
            buf += len_in_blk;
        }
    }
    
    return ret_len;
}



U32 aos_page_write( page_t *page, U8 *buf, U32 len )
{
    U32 write_len;
    
    if( !page || (PAGE_MAGIC != page->magic_num) )
    {
        AOS_ASSERT( 0 );
        return 0;
    }

    write_len = aos_page_write_off( page, page->write_ptr, buf, len );
    page->write_ptr += write_len;
    
    return write_len;
}


U32 aos_page_write_off( page_t *page, U32 off, U8 *buf, U32 len )
{
    U32 new_blk_num, blk_no, off_in_blk, len_in_blk, ret_len;
    U8 *new_blk;
    
    if( !page || !len || (PAGE_MAGIC != page->magic_num) )
    {
        AOS_ASSERT( 0 );
        return 0;
    }

    ret_len = len;

    
    if( ( off + len ) <= page->page_size )
    {
        goto write_inner_page;
    }

    
    if( ( off + len ) <= ( page->ext_mem_size + page->blk_size *page->blk_num ) )
    {
        page->page_size = off + len;
        goto write_inner_page;
    }

    new_blk_num = (off + len - page->ext_mem_size - page->blk_size *page->blk_num + page->blk_size - 1)/page->blk_size;

    
    if( ( page->blk_num + new_blk_num ) >= page->max_blk_num )
    {
        AOS_ASSERT_FUNC( 0, aos_printf( 0, "page 0x%x blk_num %u too large", page, page->blk_num ) );
        return 0;
    }

    for( blk_no = 0; blk_no < new_blk_num; blk_no++ )
    {
        new_blk = aos_dmem_alloc( page->mpe, SID_PAGE_BLK, page->blk_size );
        if( NULL == new_blk )
        {
            
            AOS_ASSERT_FUNC( 0, aos_printf( 0, "page 0x%x append fail,len=%u", page, page->page_size ) );
            return 0;
        }
        page->blk_ptr[page->blk_num++] = new_blk;
    }
    
    page->page_size = off + len;
    
write_inner_page:
    
    if( off < page->ext_mem_size )
    {
        len_in_blk = page->ext_mem_size - off;
        if( len_in_blk >= len )
        {
            aos_memcpy( page->ext_mem_ptr + off, buf, len );
            return len;
        }
        
        aos_memcpy( page->ext_mem_ptr + off, buf, len_in_blk );
        off = 0;
        buf += len_in_blk;
        len -= len_in_blk;
    }
    else
    {
        off -= page->ext_mem_size;
    }

    for( ;; )
    {
        blk_no     = off / page->blk_size;
        off_in_blk = off % page->blk_size;
        len_in_blk = page->blk_size - off_in_blk;
        
        if( len_in_blk >= len )
        {
            aos_memcpy( &page->blk_ptr[blk_no][off_in_blk], buf, len );
            break;
        }
        else
        {
            aos_memcpy( &page->blk_ptr[blk_no][off_in_blk], buf, len_in_blk );
            len -= len_in_blk;
            off += len_in_blk;
            buf += len_in_blk;
        }
    }
    
    return ret_len;
}

U32 aos_page_append( page_t *page, U8 *ptr, U32 size )
{
    if( !page || (PAGE_MAGIC != page->magic_num) || ( NULL == ptr ) )
    {
        AOS_ASSERT( 0 );
        return AOS_FAIL;
    }

    
    if( page->ext_mem_ptr 
     || page->ext_mem_size
     || page->read_ptr
     || page->write_ptr )
    {
        AOS_ASSERT( 0 );
        return AOS_FAIL;
    }

    page->ext_mem_ptr = ptr;
    page->ext_mem_size = size;

    return AOS_SUCC;
}

#endif

#ifdef	__cplusplus
}
#endif