uboot_file.c

Go to the documentation of this file.

/*
 *  CMSIS2000
 *  CMSIS-like sources for LPC2xxx series MCUs
 *
 *  (C) Copyright 2011-2012, Dmitriy Cherepanov, All Rights Reserved
 *
 *  Version: 0.0.7
 *  Date of the Last Update:  2013-03-04
 *  
 *  Permission is hereby granted, free of charge, to any person obtaining a copy
 *  of this software and associated documentation files (the "Software"), to
 *  deal in the Software without restriction, including without limitation the
 *  rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 *  sell copies of the Software, and to permit persons to whom the Software is
 *  furnished to do so, subject to the following conditions:
 *
 *  The above copyright notice and this permission notice shall be included in
 *  all copies or substantial portions of the Software.
 *
 *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 *  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 *  IN THE SOFTWARE.
 *
 *  Do not be lasy! For the latest version see http://irtos.sourceforge.net .
 *
 *  
#*/
/*----------------------------------------------------------------------------*/
/**
\file find and load file in memory
\author Cherepanov Dmitiy
*/
/*----------------------------------------------------------------------------*/
#include "uboot_file.h"
#include <string.h>
/*----------------------------------------------------------------------------*/
#define IMAGE_STEP      0x100

/*----------------------------------------------------------------------------*/

static flash_addr_t uboot_check_image_not_aligned (flash_addr_t search_start_address,
                                                flash_addr_t search_end_address);
/*----------------------------------------------------------------------------*/
flash_addr_t find_uboot_file(flash_addr_t search_start_address,
                                flash_addr_t search_end_address)
{
flash_addr_t i = search_start_address;

        if (uboot_check_image_at_addr((const void * const)i,HAS_FULL_IMAGE))
                        return i;

        for (i= (i + (IMAGE_STEP - 1))&(~(IMAGE_STEP - 1));
                i < search_end_address;i+=IMAGE_STEP) {
                        if (uboot_check_image_at_addr((const void * const)i,
                                                        HAS_FULL_IMAGE))
                                                                return i;
        };

        i = uboot_check_image_not_aligned(search_start_address,search_end_address);
        if (i != 0)
                return i;
        else
                return( (flash_addr_t )(-1));
};

#include "uboot_image_format_adapted.h" /*---UBOOT HEADER ----------*/

#ifdef UBOOT_APPLIC_NAME_START
//      #define UBOOT_APPLIC_NAME_START "linu"
const char uboot_applic_name_str[] = UBOOT_APPLIC_NAME_START;
#endif // UBOOT_APPLIC_NAME_START
/*----------------------------------------------------------------------------*/
unsigned int uboot_check_image_at_addr (const void * const addr,char only_header)
{
        const struct image_header * const img_hdr = (const struct image_header * const )addr;

        if (    image_check_magic(img_hdr) &&
                image_check_hcrc (img_hdr) &&
                image_check_arch (img_hdr,IH_ARCH_DEFAULT)
/*
                image_check_os(img_hdr,IH_OS_INVALID)  &&
                image_check_type(img_hdr,IH_TYPE_FIRMWARE)  &&
*/
        ) {
#ifdef UBOOT_APPLIC_NAME_START
                if (memcmp (image_get_name(img_hdr),uboot_applic_name_str) == 0)
#endif
                        if (only_header) {
                                return 1;
                        } else {
                                //if (image_check_dcrc(img_hdr))
                                        return 1;
                        }
        }
return 0;
}
/*----------------------------------------------------------------------------
flash_addr_t uboot_file_load_and_check_crc (flash_addr_t src_address, uint32_t no_need_crc )
{
struct image_header * img = (struct image_header * )src_address;

        if (image_get_comp(img) == IH_COMP_NONE) {
                if (no_need_crc != 0) {
                        memcpy((void *)  image_get_load(img),
                                (void *) image_get_data(img),
                                image_get_data_size(img));
                } else {
                        no_need_crc = crc32_and_load((void *) image_get_data(img),
                                image_get_data_size(img),(void *) image_get_load(img));
                        if (no_need_crc != image_get_dcrc(img))
                                return ((flash_addr_t )(-1));
                }

        #if defined(USE_COMP)
        } else if (image_get_comp(img) == IH_COMP_LZO){
                decompress ((void *)  image_get_load(img),
                (void *) image_get_data(img),
                image_get_data_size(img));
        #endif
        } else {
                return( (flash_addr_t )(-1));
        }
return image_get_ep(img);
};*/

/*----------------------------------------------------------------------------*/
static inline void * round_down_pointer(void *  ptr)
{
unsigned int p = (unsigned int ) ptr;
        return ( void * )(p  & (~(0x3)));
}
flash_addr_t uboot_file_load (flash_addr_t src_address )
{
struct image_header * img = (struct image_header * )src_address;
void * dst = image_get_load(img);
size_t size  = image_get_data_size(img);

        if (image_get_comp(img) == IH_COMP_NONE) {
                /* fill zero to the end of RAM data */
                *(unsigned int *)round_down_pointer(dst+size) = 0;
                memcpy (dst, (void *) image_get_data(img), size);
        #if defined(USE_COMP)
        } else if (image_get_comp(img) == IH_COMP_LZO){
                decompress (dst, (void *) image_get_data(img), size);
        #endif
        } else {
                return( (flash_addr_t )(-1));
        }
return image_get_ep(img);
};
/*----------------------------------------------------------------------------*/
flash_addr_t uboot_file_get_load_addr(flash_addr_t src_address )
{
        return image_get_load((struct image_header * )src_address);
}
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
#include "Utils/CRC/crc32.h"

int image_check_hcrc(const image_header_t * const hdr)
{
        size_t len = image_get_header_size();

        uint32_t hcrc = 0xa8dc0d46; /*let free compiler from calculating const value*/
        /*uint32_t hcrc = crc32_init();
        hcrc  = crc32_update(hcrc, (uint8_t)(IH_MAGIC>>24) & 0xFF);
        hcrc  = crc32_update(hcrc, (uint8_t)(IH_MAGIC>>16) & 0xFF);
        hcrc  = crc32_update(hcrc, (uint8_t)(IH_MAGIC>>8) & 0xFF);
        hcrc  = crc32_update(hcrc, (uint8_t)(IH_MAGIC>>0) & 0xFF);
        hcrc  = crc32_update(hcrc, (uint8_t)0);
        hcrc  = crc32_update(hcrc, (uint8_t)0);
        hcrc  = crc32_update(hcrc, (uint8_t)0);
        hcrc  = crc32_update(hcrc, (uint8_t)0); */

        hcrc  = crc32_no_comp(hcrc,
                ((unsigned char *)hdr) + sizeof(hdr->ih_magic) + sizeof(hdr->ih_hcrc),
                len - sizeof(hdr->ih_magic)-sizeof(hdr->ih_hcrc));

        hcrc = crc32_end(hcrc);
        return (hcrc == image_get_hcrc(hdr));
}
/*----------------------------------------------------------------------------*/
int image_check_dcrc(const image_header_t *hdr)
{
        uint32_t  dcrc = crc32( 0,
                                 ((unsigned char *)image_get_data(hdr)),
                                 (size_t ) image_get_data_size(hdr)
        );
        return (dcrc == image_get_dcrc(hdr));
}
/*----------------------------------------------------------------------------*/
//#include <string.h>
/*
static inline int_fast8_t has_magic_number_byte(uint_fast32_t data)
{
        const uint_fast8_t magic_number0 = ((IH_MAGIC>>24) & 0xFF);
        const uint_fast8_t magic_number1 = (IH_MAGIC>>16) & 0xFF);
        const uint_fast8_t magic_number2 = (IH_MAGIC>>8) & 0xFF);
        const uint_fast8_t magic_number3 = (IH_MAGIC>>0) & 0xFF);
        const uint_fast32_t magic_number0 = magic_number0 +magic_number1 <<8 + magic_number2 <<16
        magic_number3<<24;
        const uint_fast32_t magic_number1 = magic_number0 + magic_number1 <<8 + magic_number2 <<16;
        const uint_fast32_t magic_number2 = magic_number0 + magic_number1 <<8 ;
        const uint_fast32_t magic_number3 = magic_number0 ;


        if (data == magic_number0)
                return 0;
        data = data >> 8;
        if (data == magic_number1)
                return 1;
        if (data == magic_number2)
                return 2;
        if (data == magic_number3)
                return 3;
        else return (int_fast8_t) -1;
}
*/
#define END_SEARCH 0
static unsigned char * memmem_magic_number(unsigned char * src, size_t size)
{
        const uint_fast32_t magic_num =  be32_to_cpu(IH_MAGIC);
        while (size-- > 0){
                if (*src == (magic_num& 0xFF)){
                                /*not worked at armtmi */
                        uint_fast32_t data = *(uint32_t *) src;
                        if (data  == magic_num)
                                return src;
                }
                src++; /*src+=has_magic_number_byte;*/
        }/* has not found */
        return (unsigned char *) END_SEARCH;
}
/** search not aligned image*/
static flash_addr_t uboot_check_image_not_aligned (flash_addr_t search_start_address,
                                                flash_addr_t search_end_address)
{

        uint32_t i = search_start_address;
        do {
                i = (flash_addr_t)memmem_magic_number((void *)i, search_end_address
                                - i - sizeof(image_header_t) );
                if (i != ((flash_addr_t) END_SEARCH) )
                        if (uboot_check_image_at_addr((const void * const)i,
                                                                HAS_FULL_IMAGE))
                                break;
                i++;
        } while (i != END_SEARCH);
        return i;
}