source: umon/main/common/cstart.c @ 87db514

/**************************************************************************
 *
 * Copyright (c) 2013 Alcatel-Lucent
 * 
 * Alcatel Lucent licenses this file to You under the Apache License,
 * Version 2.0 (the "License"); you may not use this file except in
 * compliance with the License.  A copy of the License is contained the
 * file LICENSE at the top level of this repository.
 * You may also obtain a copy of the License at:
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **************************************************************************
 *
 * cstart.c:
 * This is the first 'C' code exececuted by the processor after a reset if
 * the monitor is built to boot and copy itself into RAM.
 * 
 * This 2-stage monitor is done with two distinct images.
 * The first image (the real "boot" image) includes this cstart() code
 * in place of normal start().  The make process generates the umon.c file
 * included below.  This file is essentially a C-array that consists of
 * the binary image (second image) of a version of the monitor that is
 * built to run out of RAM.  The value of UMON_RAMBASE is the base address
 * of this image and the value of UMON_START is the entry point into this
 * image.
 *
 * Original author:     Ed Sutter (ed.sutter@alcatel-lucent.com)
 *
 */
#include "config.h"
#include "stddefs.h"
#include "cpu.h"

#ifdef ROM_MONSTACKSIZE
ulong   MonStack[ROM_MONSTACKSIZE/4];
#endif

/* The umon.c file is simply an array that contains the monitor
 * image and the necessary information needed to do the copy.
 */
#include "umon.c"

char *
memcpy(char *to,char *from,int count)
{
        char    *to_copy, *end;

        to_copy = to;

        /* If count is greater than 8, get fancy, else just do byte-copy... */
        if (count > 8) {
                /* Attempt to optimize the transfer here... */
                if (((int)to & 3) && ((int)from & 3)) {
                        /* If from and to pointers are both unaligned to the
                         * same degree then we can do a few char copies to get them
                         * 4-byte aligned and then do a lot of 4-byte aligned copies.
                         */
                        if (((int)to & 3) == ((int)from & 3)) {
                                while((int)to & 3) {
                                        *to++ = *from++;
                                        count--;
                                }
                        }
                        /* If from and to pointers are both odd, but different, then
                         * we can increment them both by 1 and do a bunch of 2-byte
                         * aligned copies...
                         */
                        else if (((int)to & 1) && ((int)from & 1)) {
                                *to++ = *from++;
                                count--;
                        }
                }
        
                /* If both pointers are now 4-byte aligned or 2-byte aligned,
                 * take advantage of that here...
                 */
                if (!((int)to & 3) && !((int)from & 3)) {
                        end = to + (count & ~3);
                        count = count & 3;
                        while(to < end) {
                                *(ulong *)to = *(ulong *)from;
                                from += 4;
                                to += 4;
                        }
                }
                else if (!((int)to & 1) && !((int)from & 1)) {
                        end = to + (count & ~1);
                        count = count & 1;
                        while(to < end) {
                                *(ushort *)to = *(ushort *)from;
                                from += 2;
                                to += 2;
                        }
                }
        }

        if (count) {
                end = to + count;
                while(to < end)
                        *to++ = *from++;
        }
        return(to_copy);
}

void
cstart(void)
{
        register long *lp1, *lp2, *end2;
        void (*entry)();
        
        entry = (void(*)())UMON_START;

        /* Copy image from boot flash to RAM, then verify the copy.
         * If it worked, then jump into that space; else reset and start
         * over (not much else can be done!).
         */
        memcpy((char *)UMON_RAMBASE,(char *)umon,(int)sizeof(umon));

        /* Verify the copy...
         */
        lp1 = (long *)UMON_RAMBASE;
        lp2 = (long *)umon;
        end2 = lp2 + (int)sizeof(umon)/sizeof(long);
        while(lp2 < end2) {
                if (*lp1 != *lp2) {
#ifdef CSTART_ERROR_FUNCTION
                        extern void CSTART_ERROR_FUNCTION();

                        CSTART_ERROR_FUNCTION(lp1,*lp1,*lp2);
#endif
#ifdef INLINE_RESETFUNC
                        INLINE_RESETFUNC();
#else
                        entry = RESETFUNC();
#endif
                        break;
                }
                lp1++; lp2++;
        }
        entry();
}