Changeset 425 for trunk/softs


Ignore:
Timestamp:
Jun 30, 2013, 8:28:58 PM (11 years ago)
Author:
cfuguet
Message:

Modifications in tsar_boot:

  • Creating new files boot_utils.[c h] containing the memcpy, memset and some ELF format debug functions
  • Introducing assert in the boot_elf_loader to show an error when some of segments to load conflicts with some of the pre-loader segments
  • Cosmetic changes in boot_elf_loader to improve code readibility
  • Fixing bug in dcache_buf_invalidate function used by boot_ioc_read when cache coherence not supported. The condition in the for loop was erroneous.
  • Modification in Makefile: The SYSCLK_FREQ parameter is not passed anymore

as a Makefile parameter but it is definesd in the defs_platform.h file

Location:
trunk/softs/tsar_boot
Files:
2 added
4 deleted
9 edited

Legend:

Unmodified
Added
Removed
  • trunk/softs/tsar_boot/Makefile

    r411 r425  
    22-include ./build.mk
    33
    4 ifndef MAKECMDGOALS
    5   MAKECMDGOALS=none
    6 endif
     4MAKECMDGOALS ?= none
    75
    86ifneq ($(MAKECMDGOALS),$(filter $(MAKECMDGOALS),clean distclean clean-doc doc))
     
    1917    endif
    2018  endif
    21 endif
    22 
    23 ifeq ($(USE_DT), 0)
    24         DTS=
    2519endif
    2620
     
    5852
    5953CFLAGS     := -Wall -mno-gpopt -ffreestanding -fomit-frame-pointer -mips32 \
    60                       -ggdb -mlong-calls
     54                      -ggdb -mlong-calls -Werror
    6155
    62 C_SRCS     := boot_elf_loader.c boot_ioc.c boot_memcpy.c boot_tty.c exceptions.c
     56C_SRCS     := boot_elf_loader.c boot_ioc.c boot_utils.c boot_tty.c exceptions.c
    6357
    6458ifndef SOCLIB
     
    7468TARGET     := bin.soft
    7569
    76 ifndef USE_DT
    77   USE_DT := 1
    78 else
    79   USE_DT := $(USE_DT)
    80 endif
    81 
    82 ifdef SYSCLK_FREQ
    83   DEFS += -DSYSCLK_FREQ=$(SYSCLK_FREQ)
    84 endif
     70USE_DT     ?= 1
    8571
    8672all: $(TARGET)
     
    9177        $(DU) -D $@ > $@.txt
    9278
     79ifeq ($(USE_DT), 1)
    9380$(BUILD_DIR)/platform.ld: $(BUILD_DIR)/platform.dtb
    9481        $(ECHO) "[ HEXDUMP ]     $(notdir $<)"
    9582        $(HEXDUMP) -v -e '"BYTE(0x" 1/1 "%02X" ")\n"' $< > $@
     83else
     84$(BUILD_DIR)/platform.ld:
     85        $(ECHO) "[  TOUCH  ]     $(notdir $@)"
     86        touch $@
     87endif
    9688
    9789$(BUILD_DIR)/platform.dtb: $(DTS)
    98 ifeq ($(USE_DT), 1)
    9990        $(ECHO) "[   DTC   ]     $(notdir $<)"
    10091        ${DTC} -O dtb -o $@ $< &> /dev/null
    101 else
    102         touch $@
    103 endif
    10492
    10593$(BUILD_DIR):
  • trunk/softs/tsar_boot/README.txt

    r390 r425  
    1717             the TTY, IOC and XICU devices.
    1818             It defines also:
     19
    1920              -> CACHE_COHERENCE
    2021                 This constant is used by the boot_ioc_read function to know
     
    2223                 must be invalidated in the dcache after the transfert has
    2324                 finished.
    24                                  0 means invalidation must be made.
    25 
    26               -> INSTRUMENTATION
    27                  Set value different to 0 if some instrumentation of the
    28                  bootloader is needed.
    2925
    3026              -> CACHE_LINE_SIZE
     27                 This constant is mandatory if CACHE_COHERENCE=0
    3128                 This constant defines the size in bytes of a cache line.
     29
     30              -> BOOT_DEBUG
     31                 Set value to 1 to show some debug messages during loading
     32
     33              -> BOOT_DEBUG_IOC
     34                 Set value to 1 to show some debug messages during loading
     35                 concerning the disk accesses.
    3236
    3337              -> IRQ_PER_PROC
     
    3741      --->  platform_soclib.dts:
    3842
    39              Device tree file. It is mandatory if compiling
    40              for a SOCLIB platform. If the application to execute does not use
    41              a device tree file, create an empty one.
     43             Device tree file. It is mandatory if compiling for a SOCLIB
     44             platform and USE_DT=1.
    4245
    4346      --->  platform_fpga.dts:
    4447
    45              Device tree file. It is mandatory if compiling
    46              for a FPGA platform. If the application to execute does not use
    47              a device tree file, create an empty one.
     48             Device tree file. It is mandatory if compiling for a FPGA platform
     49             and USE_DT=1.
    4850
    4951      --->  ldscript:
     
    7072                   drivers
    7173
    72              ---> SYSCLK_FREQ=<value hz>
     74             ---> USE_DT=0
    7375
    74                    If not SOCLIB platform, this flag allows us to choose the
    75                    CLK frequency used in the hardware platform (i.e. FPGA).
    76                    This information is used to configurate the SPI device
    77                    which allow us to drive a SD card device.
     76                   If a device tree file is not used, set this flag to 0. It
     77                   is set by default to 1.
    7878
    79               i.e. make PLATFORM_DIR=conf/<platform_dir> SYSCLK_FREQ=50000000
    80                    make PLATFORM_DIR=conf/<platform_dir> SOCLIB=1
     79              e.g. make PLATFORM_DIR=conf/<platform_dir> SOCLIB=1 USE_DT=0
  • trunk/softs/tsar_boot/conf/platform_fpga_de2-115/defs_platform.h

    r412 r425  
    77#define CACHE_LINE_SIZE 64//bytes
    88
    9 #define BOOT_DEBUG      0
     9#define BOOT_DEBUG      1
    1010#define BOOT_DEBUG_IOC  0
    1111
     
    1313#define TTY_BASE        0xFC000000
    1414#define ICU_BASE        0xFD000000
     15
     16/* Mandatory argument only for FPGA platforms */
     17
     18#define SYSCLK_FREQ     25000000//Hz
  • trunk/softs/tsar_boot/conf/platform_vgsb_xicu_mmu/defs_platform.h

    r412 r425  
    77#define CACHE_LINE_SIZE 16//bytes
    88
     9#define BOOT_DEBUG      1
     10#define BOOT_DEBUG_IOC  0
     11
    912#define ICU_BASE        0x00F00000
    1013#define IOC_BASE        0x00F10000
  • trunk/softs/tsar_boot/conf/platform_vgsb_xicu_mmu/ldscript

    r368 r425  
    77/* Definition of the base address for all segments */
    88
    9 seg_stack_base    = 0x00108000;
     9seg_stack_base    = 0x00018000;
    1010seg_boot_base     = 0xBFC00000;       /* le code de boot */
    1111
  • trunk/softs/tsar_boot/include/defs.h

    r292 r425  
    33#define BOOT_VERSION    0x00010001
    44
    5 #define BOOT_STACK_SIZE 0x8000     /* 32 KB */
     5#define BOOT_STACK_SIZE 0x4000     /* 16 KB */
    66#define BOOT_LOADER_LBA 2
    77#define PHDR_ARRAY_SIZE 16
  • trunk/softs/tsar_boot/src/boot_elf_loader.c

    r415 r425  
    11/**
    2  * \file    : boot_loader_entry.c
     2 * \file    : boot_elf_loader.c
    33 * \date    : August 2012
    44 * \author  : Cesar Fuguet
     
    1313#include <elf-types.h>
    1414#include <boot_tty.h>
    15 #include <boot_memcpy.h>
     15#include <boot_utils.h>
    1616#include <defs.h>
     17
     18#if (BOOT_DEBUG == 1)
     19static char* init_state_str[] = {
     20    "ELF_HEADER_STATE",
     21    "ELF_PROGRAM_HEADER_STATE",
     22    "ELF_OFFSET_STATE",
     23    "ELF_SEGMENT_STATE",
     24    "ELF_END_STATE"
     25};
     26#endif
    1727
    1828void * boot_elf_loader(unsigned int lba)
    1929{
    20     /**
     30    /*
    2131     * Temporary variables used by the boot loader
    2232     */
     
    2636
    2737    unsigned char * buffer_ptr;
    28     Elf32_Ehdr    * elf_header_ptr;
    29     Elf32_Phdr    * elf_pht_ptr;
     38    Elf32_Ehdr    * elf_ehdr_ptr;
     39    Elf32_Phdr    * elf_phdr_ptr;
    3040
    3141    unsigned int nb_available;
     
    3444    unsigned int nb_block;
    3545    unsigned int offset;
     46
     47    unsigned char * pseg_ptr;
     48    unsigned int pseg_start;
     49    unsigned int pseg_end;
     50    unsigned int pseg_remainder;
    3651    unsigned int pseg;
    37     unsigned int i;
    38     unsigned int segment_req;
    3952
    4053    /*
    4154     * Loader state machine definition
    4255     */
    43     enum
     56    typedef enum
    4457    {
    4558        ELF_HEADER_STATE,
     
    4861        ELF_SEGMENT_STATE,
    4962        ELF_END_STATE
    50     } init_state
    51 #if (BOOT_DEBUG ==1)
    52     , init_state_debug
    53 #endif
    54         ;
    55 
    56 #if (BOOT_DEBUG == 1)
    57     char* init_state_str[] = {
    58         "ELF_HEADER_STATE",
    59         "ELF_PROGRAM_HEADER_STATE",
    60         "ELF_OFFSET_STATE",
    61         "ELF_SEGMENT_STATE",
    62         "ELF_END_STATE"
    63     };
    64 #endif
    65 
     63    } elf_loader_t;
     64
     65    elf_loader_t init_state;
     66    init_state = ELF_HEADER_STATE;
     67
     68#if (BOOT_DEBUG == 1)
     69    elf_loader_t init_state_debug;
     70    init_state_debug = ELF_END_STATE;
     71#endif
    6672
    6773    boot_puts("Starting boot_elf_loader function...\n\r");
    6874
    69     nb_block           = lba;
    70 
    71     pseg               = 0;
    72     nb_available       = 0;
    73     nb_rest            = sizeof(Elf32_Ehdr);
    74     offset             = 0;
    75 
    76     elf_header_ptr     = (Elf32_Ehdr *) &elf_header;
    77     elf_pht_ptr        = (Elf32_Phdr *) &elf_pht[0];
    78 
    79     init_state         = ELF_HEADER_STATE;
    80 #if (BOOT_DEBUG == 1)
    81     init_state_debug   = ELF_END_STATE;
    82 #endif
     75    nb_block     = lba;
     76    nb_available = 0;
     77    nb_rest      = sizeof(Elf32_Ehdr);
     78    pseg         = 0;
     79    offset       = 0;
     80    elf_ehdr_ptr = (Elf32_Ehdr *) &elf_header;
     81    elf_phdr_ptr = (Elf32_Phdr *) &elf_pht[0];
    8382
    8483    while(init_state != ELF_END_STATE)
    8584    {
    86         if (nb_available == 0)
     85        if (nb_available == 0 )
    8786        {
    8887            buffer_ptr = &boot_elf_loader_buffer[0];
    8988
    90             if ( boot_ioc_read(nb_block , buffer_ptr, 1) )
     89            if (boot_ioc_read(nb_block , buffer_ptr, 1))
    9190            {
    9291                boot_puts (
    9392                    "ERROR: "
    94                     "IOC_FAILED"
     93                    "boot_ioc_read() failed"
    9594                    "\n"
    9695                );
     
    118117        switch(init_state)
    119118        {
    120             /**
     119            /*
    121120             * Reading ELF executable header
    122121             */
    123122            case ELF_HEADER_STATE:
    124                 boot_memcpy(elf_header_ptr, buffer_ptr, nb_read);
     123                memcpy(elf_ehdr_ptr, buffer_ptr, nb_read);
    125124
    126125                nb_rest -= nb_read;
     
    128127                if(nb_rest == 0)
    129128                {
    130                     nb_rest = elf_header_ptr->e_phnum * elf_header_ptr->e_phentsize;
    131 
    132                     /* Verification of ELF Magic Number */
    133                     if (
    134                         (elf_header_ptr->e_ident[EI_MAG0] != ELFMAG0) ||
    135                         (elf_header_ptr->e_ident[EI_MAG1] != ELFMAG1) ||
    136                         (elf_header_ptr->e_ident[EI_MAG2] != ELFMAG2) ||
    137                         (elf_header_ptr->e_ident[EI_MAG3] != ELFMAG3) )
     129                    nb_rest = elf_ehdr_ptr->e_phnum * elf_ehdr_ptr->e_phentsize;
     130
     131                    /*
     132                     * Verification of ELF Magic Number
     133                     */
     134                    if ( (elf_ehdr_ptr->e_ident[EI_MAG0] != ELFMAG0) ||
     135                         (elf_ehdr_ptr->e_ident[EI_MAG1] != ELFMAG1) ||
     136                         (elf_ehdr_ptr->e_ident[EI_MAG2] != ELFMAG2) ||
     137                         (elf_ehdr_ptr->e_ident[EI_MAG3] != ELFMAG3) )
    138138                    {
    139139                        boot_puts(
     
    150150                     * smaller than the work size allocated for the
    151151                     * elf_pht[PHDR_ARRAY_SIZE] array
    152                      **/
    153                     if (elf_header_ptr->e_phnum > PHDR_ARRAY_SIZE)
     152                     */
     153                    if (elf_ehdr_ptr->e_phnum > PHDR_ARRAY_SIZE)
    154154                    {
    155155                        boot_puts(
    156156                            "ERROR: "
    157                             "ELF PHDR table size is bigger than "
    158                             "the allocated work space"
     157                            "ELF PHDR table size is bigger than the allocated"
     158                            "work space"
    159159                            "\n"
    160160                        );
     
    168168                break;
    169169
    170             /**
     170            /*
    171171             * Reading ELF program headers
    172172             */
    173173            case ELF_PROGRAM_HEADER_STATE:
    174                 boot_memcpy(elf_pht_ptr, buffer_ptr, nb_read);
    175 
    176                 elf_pht_ptr = (Elf32_Phdr *)((unsigned char *) elf_pht_ptr + nb_read);
    177                 nb_rest    -= nb_read;
     174                memcpy(elf_phdr_ptr, buffer_ptr, nb_read);
     175
     176                elf_phdr_ptr =
     177                    (Elf32_Phdr *)((unsigned char *) elf_phdr_ptr + nb_read);
     178
     179                nb_rest -= nb_read;
    178180
    179181                if(nb_rest == 0)
    180182                {
    181                     elf_pht_ptr = (Elf32_Phdr *) &elf_pht[0];
     183                    elf_phdr_ptr = (Elf32_Phdr *) &elf_pht[0];
    182184
    183185                    /*
    184186                     * Search the first not NULL segment in the ELF file
    185187                     */
    186                     for (pseg = 0; pseg < elf_header_ptr->e_phnum; pseg++)
    187                     {
    188                         if(elf_pht_ptr[pseg].p_type == PT_LOAD)
     188                    for (pseg = 0; pseg < elf_ehdr_ptr->e_phnum; pseg++)
     189                    {
     190                        if(elf_phdr_ptr[pseg].p_type == PT_LOAD)
    189191                        {
    190192#if (BOOT_DEBUG == 1)
    191                             boot_puts("found a loadable segment:");
    192                             boot_puts("\n- type   : "); boot_putx(elf_pht_ptr[pseg].p_type);
    193                             boot_puts("\n- offset : "); boot_putx(elf_pht_ptr[pseg].p_offset);
    194                             boot_puts("\n- vaddr  : "); boot_putx(elf_pht_ptr[pseg].p_vaddr);
    195                             boot_puts("\n- paddr  : "); boot_putx(elf_pht_ptr[pseg].p_paddr);
    196                             boot_puts("\n- filesz : "); boot_putx(elf_pht_ptr[pseg].p_filesz);
    197                             boot_puts("\n- memsz  : "); boot_putx(elf_pht_ptr[pseg].p_memsz);
    198                             boot_puts("\n- flags  : "); boot_putx(elf_pht_ptr[pseg].p_flags);
    199                             boot_puts("\n- align  : "); boot_putx(elf_pht_ptr[pseg].p_align);
    200 #endif
    201                             if (elf_pht_ptr[pseg].p_offset < offset)
     193                            boot_puts("loadable segment found:\n");
     194                            boot_print_elf_phdr(&elf_phdr_ptr[pseg]);
     195#endif
     196                            if (elf_phdr_ptr[pseg].p_offset < offset)
    202197                            {
    203198                                /*
    204                                  * Case where the segment to load includes the elf
    205                                  * and program headers
    206                                  * */
    207                                 nb_rest = elf_pht_ptr[pseg].p_filesz - offset;
     199                                 * Case where the segment to load includes the
     200                                 * elf and program headers
     201                                 */
     202                                nb_rest = elf_phdr_ptr[pseg].p_filesz - offset;
    208203                                init_state = ELF_SEGMENT_STATE;
    209204                            }
     
    212207                                /*
    213208                                 * Segment to load is further away in ELF file
    214                                  * */
    215                                 nb_rest = elf_pht_ptr[pseg].p_offset - offset;
     209                                 */
     210                                nb_rest = elf_phdr_ptr[pseg].p_offset - offset;
    216211                                init_state = ELF_OFFSET_STATE;
    217212                            }
     
    220215                    }
    221216
    222                     if (pseg == elf_header_ptr->e_phnum)
     217                    if (pseg == elf_ehdr_ptr->e_phnum)
    223218                    {
    224219                        boot_puts(
     
    234229                break;
    235230
    236             /**
     231            /*
    237232             * Go to the offset of the first not null program segment in the
    238233             * ELF file
     234             *
     235             * TODO:
     236             * No need to read from the disk the useless bytes. Try to compute
     237             * the next usefull lba
    239238             */
    240239            case ELF_OFFSET_STATE:
     
    243242                if (nb_rest == 0)
    244243                {
    245                     nb_rest    = elf_pht_ptr[pseg].p_filesz;
     244                    nb_rest    = elf_phdr_ptr[pseg].p_filesz;
    246245                    init_state = ELF_SEGMENT_STATE;
    247246                }
     
    249248                break;
    250249
    251             /**
     250            /*
    252251             * Reading ELF segments
     252             *
     253             * TODO:
     254             * Do not pass by block buffer but write directly in target memory
     255             * address
    253256             */
    254257            case ELF_SEGMENT_STATE:
    255                 /**
    256                  * Copying ELF segment data in memory segments using the virtual
    257                  * address got from the ELF file
     258                /*
     259                 * Verify that loadable segment does not conflict with
     260                 * pre-loader memory space
    258261                 */
    259                 segment_req = ((elf_pht_ptr[pseg].p_vaddr & 0xBFC00000) != 0xBFC00000);
    260 
    261                 if ( segment_req )
    262                 {
    263                     boot_memcpy((unsigned char *) elf_pht_ptr[pseg].p_vaddr +
    264                                 (elf_pht_ptr[pseg].p_filesz - nb_rest),
    265                                 buffer_ptr,
    266                                 nb_read);
    267                 }
     262                pseg_start = elf_phdr_ptr[pseg].p_vaddr;
     263
     264                pseg_end   = elf_phdr_ptr[pseg].p_vaddr +
     265                             elf_phdr_ptr[pseg].p_memsz;
     266
     267                if ((pseg_start >= 0xBFC00000 && pseg_start <= 0xBFC10000) ||
     268                    (pseg_end   >= 0xBFC00000 && pseg_end   <= 0xBFC10000) ||
     269                    (pseg_start <  0xBFC00000 && pseg_end   >  0xBFC10000))
     270                {
     271                    boot_puts(
     272                        "ERROR: "
     273                        "Program segment conflits with pre-loader memory space"
     274                        "\n"
     275                    );
     276                    boot_exit();
     277                }
     278
     279                /*
     280                 * Copy the ELF segment data in memory using the
     281                 * virtual address obtained from the ELF file
     282                 */
     283                pseg_ptr = (unsigned char *)
     284                    elf_phdr_ptr[pseg].p_vaddr  +
     285                    elf_phdr_ptr[pseg].p_filesz -
     286                    nb_rest;
     287
     288                memcpy(pseg_ptr, buffer_ptr, nb_read);
    268289
    269290                nb_rest -= nb_read;
    270291
    271                 if ( nb_rest == 0 )
    272                 {
    273                     if ( segment_req )
    274                     {
    275                         boot_puts("Copied segment at address ");
    276                         boot_putx(elf_pht_ptr[pseg].p_vaddr);
    277                         boot_puts("\n");
    278 
    279                         /*
    280                          * Fill remaining bytes with zeros (filesz < memsz)
    281                          */
    282                         for ( i = 0                                                        ;
    283                               i < (elf_pht_ptr[pseg].p_memsz - elf_pht_ptr[pseg].p_filesz) ;
    284                               i--                                                          )
     292                if (nb_rest == 0)
     293                {
     294                    /*
     295                     * Fill remaining bytes with zeros (filesz < memsz)
     296                     */
     297                    pseg_remainder =
     298                        elf_phdr_ptr[pseg].p_memsz  -
     299                        elf_phdr_ptr[pseg].p_filesz ;
     300
     301                    pseg_ptr = (unsigned char *)
     302                        elf_phdr_ptr[pseg].p_vaddr  +
     303                        elf_phdr_ptr[pseg].p_filesz ;
     304
     305                    memset(pseg_ptr, 0, pseg_remainder);
     306
     307                    boot_puts("Copied segment at address ");
     308                    boot_putx(elf_phdr_ptr[pseg].p_vaddr);
     309                    boot_puts("\n");
     310
     311                    /*
     312                     * Search the next first not NULL segment in the ELF file
     313                     */
     314                    for (pseg += 1; pseg < elf_ehdr_ptr->e_phnum; pseg++)
     315                    {
     316                        if(elf_phdr_ptr[pseg].p_type == PT_LOAD)
    285317                        {
    286                             *(unsigned char *)
    287                             (elf_pht_ptr[pseg].p_vaddr + elf_pht_ptr[pseg].p_filesz + i) = 0;
    288                         }
    289                     }
    290 
    291                     /*
    292                      * Search the first not NULL segment in the ELF file
    293                      */
    294                     for ( pseg = pseg + 1; pseg < elf_header_ptr->e_phnum; pseg++) {
    295                         if(elf_pht_ptr[pseg].p_type == PT_LOAD)
    296                         {
    297                             nb_rest = elf_pht_ptr[pseg].p_offset - offset;
     318#if (BOOT_DEBUG == 1)
     319                            boot_puts("loadable segment found:\n");
     320                            boot_print_elf_phdr(&elf_phdr_ptr[pseg]);
     321#endif
     322                            nb_rest = elf_phdr_ptr[pseg].p_offset - offset;
    298323                            break;
    299324                        }
     
    303328                     * Program loading finished
    304329                     */
    305                     if(pseg == elf_header_ptr->e_phnum)
     330                    if(pseg == elf_ehdr_ptr->e_phnum)
    306331                    {
    307332                        init_state = ELF_END_STATE;
     
    317342        }
    318343
    319         buffer_ptr              += nb_read;
    320         nb_available            -= nb_read;
     344        buffer_ptr   += nb_read;
     345        nb_available -= nb_read;
    321346    }
    322347
     
    325350        "Entry point address: "
    326351    );
    327     boot_putx(elf_header_ptr->e_entry);
     352
     353    boot_putx(elf_ehdr_ptr->e_entry);
    328354    boot_puts("\n");
    329355
    330     return ((void *) elf_header_ptr->e_entry);
     356    return ((void *) elf_ehdr_ptr->e_entry);
    331357}
     358
     359// vim: tabstop=4 : softtabstop=4 : shiftwidth=4 : expandtab
  • trunk/softs/tsar_boot/src/boot_ioc.c

    r412 r425  
    55static struct sdcard_dev  _sdcard_device;
    66static struct spi_dev   * _spi_device   = ( struct spi_dev * )IOC_BASE;
    7 
    8 #ifndef SYSCLK_FREQ
    9 #warning "Using default value for SYSCLK_FREQ = 50000000"
    10 #define SYSCLK_FREQ 50000000U
    11 #endif // end ifndef SYSCLK_FREQ
    127
    138#endif // end ifndef SOCLIB_IOC
     
    266261
    267262    // iterate on cache lines
    268     for (i = 0; i < size; i += line_size) {
     263    for (i = 0; i <= size; i += line_size) {
    269264        asm volatile(
    270265            " cache %0, %1"
  • trunk/softs/tsar_boot/src/reset.S

    r349 r425  
    3434    .extern boot_ioc_read
    3535    .extern boot_elf_loader
    36     .extern boot_memcpy
     36    .extern memcpy
    3737    .extern boot_puts
    3838    .extern boot_putx
     
    5858    .word   boot_ioc_read           /* 0xbfc0018 */
    5959    .word   boot_elf_loader         /* 0xbfc001C */
    60     .word   boot_memcpy             /* 0xbfc0020 */
     60    .word   memcpy                  /* 0xbfc0020 */
    6161    .word   boot_puts               /* 0xbfc0024 */
    6262    .word   boot_putx               /* 0xbfc0028 */
Note: See TracChangeset for help on using the changeset viewer.