cyclone V CPU1启动源码【COPY】

/*
 * Copyright (c) 2013, Altera Corporation <www.altera.com>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - Neither the name of the Altera Corporation nor the
 *   names of its contributors may be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL ALTERA CORPORATION BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <sys/mman.h>
#include <stdio.h>
#include <memory.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include     <unistd.h>     //Unix 标准函数定义
#include     <termios.h>    //PPSIX 终端控制定义*/
#include     <errno.h>      //错误号定义*/

#define SYSMANAGER_ADDR_BASE  0xFFD08000
#define CPU1_LOAD_ADDR_OFFSET (0xC4/4)


#define RESET_MANAGER_BASE 0xFFD05000
#define MPU_RESET_OFFSET   (0x10/4)
#define CPU0_RESET_BIT     0
#define CPU1_RESET_BIT     1
#define CPU1_RESET_BIT_MASK 0XFFFFFFFD

#define MAP_SIZE            0X1000


#define ALT_INT_BASE_DIST 0xfffed000
#define ALT_INT_OFFSET_SGI_TRIGGER (0xf00/4)
#define ALT_INT_CONFIG_SGI_TRIGGER (0x20001)


#define LINUX_AREA_SIZE   0x10000000// 0x18000000
#define BARE_METAL_START_ADDRESS  0x10000000// 0x18000000
#define BARE_METAL_MMU_PAGE_START_ADDRESS   0x1E000000
#define BARE_METAL_MMU_PAGE_END_ADDRESS          0x20000000    /* mmu table size is 16MB */
#define GAP_START_ADDRESS  LINUX_AREA_SIZE
#define MEMORY_MAP_REGISTERS_START_ADDRESS  0XFC000000
#define MEMORY_MAP_REGISTERS_END_ADDRESS  0XFFFFFFFC

#define TEST_DATA_VALID_FLAG            0XA5A5AA55
#define TEST_DATA_LENGTH                0x2000 /* 0x00200000     (0x00800000/4)   */
#define TEST_DATA_START                     0x18000000

#define TEST_DATA_LENGTH2                0x1000/*0x001000      (0x004000/4)   */
#define TEST_DATA_START2                     0x18008000

#define JUMP_COMMAND            0xE3A0F201 //0xE3A0F306    /*     ldr pc, =0x10000000*/


int char_dev_write_data;
int char_dev_read_data;
int main(int argc, char** argv)
{
    int fd;
    int i;
    unsigned int* test_data=0;
    unsigned int* save_address=0;

    unsigned int *mapped_ptr;
    unsigned int *sgi_trigger_ptr;
    unsigned int *cpu1_reset_ptr1;
    unsigned int *cpu1_reset_ptr;
    unsigned int *cpu1_load_ptr;
    unsigned int  register_value=0xffffffff;

    unsigned char *buffer;


    fd= open("/dev/mem", O_RDWR|O_SYNC);
    if(fd < 0){
        printf(" failed to open /dev/mem\n");
        return -1;
    }

    cpu1_reset_ptr = (unsigned int *)mmap(NULL,
                                MAP_SIZE,
                                PROT_READ|PROT_WRITE,
                                MAP_SHARED,
                                fd,
                                SYSMANAGER_ADDR_BASE );
    
    if(cpu1_reset_ptr == MAP_FAILED){
        printf("mmap failed\n");
        return -1;
    }

    cpu1_reset_ptr1 = (unsigned int *)mmap(NULL,
            MAP_SIZE,
            PROT_READ|PROT_WRITE,
            MAP_SHARED,
            fd,
            0 );
    
    if(cpu1_reset_ptr1 == MAP_FAILED){
        printf("mmap1 failed \n");
        return -1;
    }


    
    mapped_ptr = (unsigned int *)mmap(NULL,
                        MAP_SIZE,
                        PROT_READ|PROT_WRITE,
                        MAP_SHARED,
                        fd,
                        RESET_MANAGER_BASE );

    if(mapped_ptr == MAP_FAILED){
        printf("mmap failed\n");
        return -1;
    }
    else
    {
        printf("mmap_ptr success1\n");
    }
    printf("1cpu1_reset_pt 0x%x\n",*(cpu1_reset_ptr+0XC4/4));
    *(cpu1_reset_ptr+CPU1_LOAD_ADDR_OFFSET) = BARE_METAL_START_ADDRESS;
    *(cpu1_reset_ptr1) = JUMP_COMMAND;//CPU1跳转命令





    printf("2cpu1_reset_pt 0x%x\n",*(cpu1_reset_ptr+CPU1_LOAD_ADDR_OFFSET));    
    register_value = *(mapped_ptr + MPU_RESET_OFFSET);
    register_value = register_value | ~CPU1_RESET_BIT_MASK;
    *(mapped_ptr + MPU_RESET_OFFSET) = register_value;
    register_value = *(mapped_ptr + MPU_RESET_OFFSET);
    usleep(1000);

    
    FILE * core1_code;


    cpu1_load_ptr = (unsigned int *)mmap(NULL,
                                    0x3000000,
                                    PROT_READ|PROT_WRITE,
                                    MAP_SHARED,
                                    fd,
                                    BARE_METAL_START_ADDRESS );

    if(cpu1_load_ptr == MAP_FAILED){
        printf("mmap cpu1_load_ptr failed\n");
        return -1;
    }
    else
    {
         printf("mmap cpu1_load_ptr success\n");
    }

    int load_length;
    int return_len;

    core1_code = fopen("/home/root/bm_core1.bin","rb");
    if(NULL==core1_code){
        printf("mmap core1_code failed...\n");
        return -1;
    }
    fseek(core1_code,0,SEEK_END);
    load_length = ftell(core1_code);
    fseek(core1_code,0,SEEK_SET);
            buffer = malloc(load_length);
    if(NULL == buffer){
            printf("MALLOC failed\n");
            return -1;
        }
    return_len = fread(buffer,1,load_length,core1_code);
    if(return_len != load_length){
        printf("mmap return_len failed\n");
        return -1;
    }
    else
    {
        printf("success load_length %d\n",return_len);
    }
    memcpy(cpu1_load_ptr,buffer,load_length);//拷贝代码在CPU1栈空间运行

    sleep(1);
    if(memcmp(cpu1_load_ptr,buffer,load_length))
    {
        printf("memcmp failed\n");
        free(buffer);
        return -1;
    }
    free(buffer);

    register_value = *(mapped_ptr + MPU_RESET_OFFSET);
    register_value = register_value &CPU1_RESET_BIT_MASK;
    *(mapped_ptr + MPU_RESET_OFFSET) = register_value;
    register_value = *(mapped_ptr + MPU_RESET_OFFSET);
    sleep(1);
    i=0;
    
    //*cpu1_reset_ptr=m2;
    for(i=0; i<0xffffff; i++)
        {
                   ;
        }
    /* harvey add to test amp code, begin */
    test_data =(unsigned int *)mmap(NULL,
                                    (0x10000),
                                    PROT_READ|PROT_WRITE,
                                    MAP_SHARED,
                                    fd,
                                    TEST_DATA_START );
                            
    if(test_data == MAP_FAILED)
    {
        printf("mmap failed\n");
        return -1;
    }
    else
    {
        printf("test_data success\n");
    }
    save_address = test_data;
    for(i=0; i<0xff; i++)
    {
    }


    // seting trigger core1
    sgi_trigger_ptr = (unsigned int *)mmap(NULL,
                        0x1000,
                        PROT_READ|PROT_WRITE,
                        MAP_SHARED,
                        fd,
                        ALT_INT_BASE_DIST );

    if(sgi_trigger_ptr == MAP_FAILED){
        printf("mmap failed\n");
        return -1;
    }
    else
    {
        printf("mmap_ptr success1\n");
    }


    signal(0, (void *)isr_bm2linux);

    isr_bm2linux(0);

    while(1)
    {
        usleep(6000000);
        test_data=save_address;

        //printf("register_value is [0]=0x%x  [1]=0x%x  [2]=0x%x  [3]=0x%x  [4]=0x%x  [5]=0x%x  [6]=0x%x  [7]=0x%x\n",test_data[0], test_data[1], test_data[2], test_data[3], test_data[4], test_data[5], test_data[6], test_data[7]);

        // trigger bm core1
        *(sgi_trigger_ptr + ALT_INT_OFFSET_SGI_TRIGGER) = ALT_INT_CONFIG_SGI_TRIGGER;
    
    }

    return 0;
}


void isr_bm2linux(int signo)
{
    printf("####in %s\n", __func__);
}