system_hbird.c

/*
 * Copyright (c) 2009-2018 Arm Limited. All rights reserved.
 * Copyright (c) 2019 HBIRD Limited. All rights reserved.
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Licensed under the Apache License, Version 2.0 (the License); you may
 * not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * 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.
 */
/******************************************************************************
 * @file     system_hbird.c
 * @brief    NMSIS HummingBird RISC-V Core Device Peripheral Access Layer Source File for
 *           HummingBird RISC-V evaluation SoC which support HummingBird RISC-V cores
 * @version  V1.00
 * @date     14. Jul 2020
 ******************************************************************************/
#include <stdint.h>
#include <stdio.h>
#include "hbird_sdk_hal.h"
 
/*----------------------------------------------------------------------------
  Define clocks
 *----------------------------------------------------------------------------*/
/* ToDo: add here your necessary defines for device initialization
         following is an example for different system frequencies */
#ifndef SYSTEM_CLOCK
#define SYSTEM_CLOCK    (80000000UL)
#endif
 
/*----------------------------------------------------------------------------
  System Core Clock Variable
 *----------------------------------------------------------------------------*/
/* ToDo: initialize SystemCoreClock with the system core clock frequency value
         achieved after system intitialization.
         This means system core clock frequency after call to SystemInit() */
uint32_t SystemCoreClock = SYSTEM_CLOCK;  /* System Clock Frequency (Core Clock) */
 
/*----------------------------------------------------------------------------
  Clock functions
 *----------------------------------------------------------------------------*/
 
void SystemCoreClockUpdate (void)            /* Get Core Clock Frequency */
{
    /* ToDo: add code to calculate the system frequency based upon the current
     *    register settings.
     * Note: This function can be used to retrieve the system core clock frequeny
     *    after user changed register settings.
     */
    SystemCoreClock = SYSTEM_CLOCK;
}
 
void SystemInit (void)
{
    /* ToDo: add code to initialize the system
     * Warn: do not use global variables because this function is called before
     * reaching pre-main. RW section maybe overwritten afterwards.
     */
    SystemCoreClock = SYSTEM_CLOCK;
}
 
#define MAX_SYSTEM_EXCEPTION_NUM        11
 
static unsigned long SystemExceptionHandlers[MAX_SYSTEM_EXCEPTION_NUM];
static unsigned long SystemExtInterruptHandlers[__PLIC_INTNUM];
static unsigned long SystemCoreInterruptHandlers[10];
 
typedef void (*EXC_HANDLER) (unsigned long mcause, unsigned long sp);
typedef void (*INT_HANDLER) (unsigned long mcause, unsigned long sp);
 
static uint32_t core_exception_handler(unsigned long mcause, unsigned long sp);
 
static void system_default_exception_handler(unsigned long mcause, unsigned long sp)
{
    /* TODO: Uncomment this if you have implement printf function */
    printf("Trap in Exception\r\n");
    printf("MCAUSE: 0x%lx\r\n", mcause);
    printf("MEPC  : 0x%lx\r\n", __RV_CSR_READ(CSR_MEPC));
    printf("MTVAL : 0x%lx\r\n", __RV_CSR_READ(CSR_MBADADDR));
    while(1);
}
 
static void system_default_interrupt_handler(unsigned long mcause, unsigned long sp)
{
    /* TODO: Uncomment this if you have implement printf function */
    printf("Trap in Interrupt\r\n");
    printf("MCAUSE: 0x%lx\r\n", mcause);
    printf("MEPC  : 0x%lx\r\n", __RV_CSR_READ(CSR_MEPC));
    printf("MTVAL : 0x%lx\r\n", __RV_CSR_READ(CSR_MBADADDR));
}
 
static void Exception_Init(void)
{
    for (int i = 0; i < MAX_SYSTEM_EXCEPTION_NUM; i++) {
        SystemExceptionHandlers[i] = (unsigned long)system_default_exception_handler;
    }
}
 
static void Interrupt_Init(void)
{
    int i;
    for (i = 0; i < __PLIC_INTNUM; i++) {
        SystemExtInterruptHandlers[i] = (unsigned long)system_default_interrupt_handler;
    }
    for (i = 0; i < 10; i++) {
        SystemCoreInterruptHandlers[i] = (unsigned long)system_default_interrupt_handler;
    }
}
 
void Exception_Register_EXC(uint32_t EXCn, unsigned long exc_handler)
{
    if ((EXCn < MAX_SYSTEM_EXCEPTION_NUM) && (EXCn >= 0)) {
        SystemExceptionHandlers[EXCn] = exc_handler;
    }
}
 
void Interrupt_Register_CoreIRQ(uint32_t irqn, unsigned long int_handler)
{
    if ((irqn <= 10) && (irqn >= 0)) {
        SystemCoreInterruptHandlers[irqn] = int_handler;
    }
}
 
void Interrupt_Register_ExtIRQ(uint32_t irqn, unsigned long int_handler)
{
    if ((irqn <= __PLIC_INTNUM) && (irqn >= 0)) {
        SystemExtInterruptHandlers[irqn] = int_handler;
    }
}
 
unsigned long Interrupt_Get_CoreIRQ(uint32_t irqn)
{
    if ((irqn <= 10) && (irqn >= 0)) {
        return SystemCoreInterruptHandlers[irqn];
    }
    return 0;
}
 
unsigned long Interrupt_Get_ExtIRQ(uint32_t irqn)
{
    if ((irqn <= __PLIC_INTNUM) && (irqn >= 0)) {
        return SystemExtInterruptHandlers[irqn];
    }
    return 0;
}
 
unsigned long Exception_Get_EXC(uint32_t EXCn)
{
    if ((EXCn < MAX_SYSTEM_EXCEPTION_NUM) && (EXCn >= 0)) {
        return SystemExceptionHandlers[EXCn];
    } else {
        return 0;
    }
}
 
uint32_t core_trap_handler(unsigned long mcause, unsigned long sp)
{
    if (mcause & MCAUSE_INTERRUPT) {
        INT_HANDLER int_handler = NULL;
        uint32_t irqn = (uint32_t)(mcause & 0X00000fff);
        if (irqn == IRQ_M_EXT) {
#if defined(__PLIC_PRESENT) && __PLIC_PRESENT == 1
            irqn = PLIC_ClaimInterrupt();
            if (irqn < __PLIC_INTNUM) {
                int_handler = (INT_HANDLER)(SystemExtInterruptHandlers[irqn]);
                if (int_handler != NULL) {
                    int_handler(mcause, sp);
                }
                PLIC_CompleteInterrupt(irqn);
            }
#endif
        } else {
            int_handler = (INT_HANDLER)(SystemCoreInterruptHandlers[irqn]);
            if (int_handler != NULL) {
                int_handler(mcause, sp);
            }
        }
        return 0;
    } else {
        return core_exception_handler(mcause, sp);
    }
}
 
static uint32_t core_exception_handler(unsigned long mcause, unsigned long sp)
{
    uint32_t EXCn = (uint32_t)(mcause & 0X00000fff);
    EXC_HANDLER exc_handler;
 
    if ((EXCn < MAX_SYSTEM_EXCEPTION_NUM) && (EXCn >= 0)) {
        exc_handler = (EXC_HANDLER)SystemExceptionHandlers[EXCn];
    } else {
        exc_handler = (EXC_HANDLER)system_default_exception_handler;
    }
    if (exc_handler != NULL) {
        exc_handler(mcause, sp);
    }
    return 0;
} /* End of Doxygen Group NMSIS_Core_ExceptionAndNMI */
 
void SystemBannerPrint(void)
{
#if defined(HBIRD_BANNER) && (HBIRD_BANNER == 1)
    printf("HummingBird SDK Build Time: %s, %s\r\n", __DATE__, __TIME__);
#ifdef DOWNLOAD_MODE_STRING
    printf("Download Mode: %s\r\n", DOWNLOAD_MODE_STRING);
#endif
    printf("CPU Frequency %lu Hz\r\n", SystemCoreClock);
#endif
}
 
int32_t Core_Register_IRQ(uint32_t irqn, void *handler)
{
    if ((irqn > 10)) {
        return -1;
    }
 
    if (handler != NULL) {
        /* register interrupt handler entry to core handlers */
        Interrupt_Register_CoreIRQ(irqn, (unsigned long)handler);
    }
    switch (irqn) {
        case SysTimerSW_IRQn:
            __enable_sw_irq();
            break;
        case SysTimer_IRQn:
            __enable_timer_irq();
            break;
        default:
            break;
    }
 
    return 0;
}
 
#if defined(__PLIC_PRESENT) && __PLIC_PRESENT == 1
 
int32_t PLIC_Register_IRQ(uint32_t source, uint8_t priority, void *handler)
{
    if ((source >= __PLIC_INTNUM)) {
        return -1;
    }
 
    /* set interrupt priority */
    PLIC_SetPriority(source, priority);
    if (handler != NULL) {
        /* register interrupt handler entry to external handlers */
        Interrupt_Register_ExtIRQ(source, (unsigned long)handler);
    }
    /* enable interrupt */
    PLIC_EnableInterrupt(source);
    __enable_ext_irq();
    return 0;
}
#endif
 /* End of Doxygen Group NMSIS_Core_ExceptionAndNMI */
 
void _premain_init(void)
{
    /* TODO: Add your own initialization code here, called before main */
    SystemCoreClock = get_cpu_freq();
#if ! defined(SIMULATION_SPIKE) && ! defined(SIMULATION_XLSPIKE)
    gpio_iof_config(GPIO, IOF0_UART0_MASK, IOF_SEL_0);
    uart_init(SOC_DEBUG_UART, 115200);
#endif
    /* Display banner after UART initialized */
    SystemBannerPrint();
    /* Initialize exception default handlers */
    Exception_Init();
    /* Initialize Interrupt default handlers */
    Interrupt_Init();
#if defined(__PLIC_PRESENT) && __PLIC_PRESENT == 1
    /* PLIC initilization */
    PLIC_Init(__PLIC_INTNUM);
#endif
}
 
void _postmain_fini(int status)
{
    /* TODO: Add your own finishing code here, called after main */
#ifdef SIMULATION_XLSPIKE
extern void xlspike_exit(int status);
    xlspike_exit(status);
#endif
#ifdef SIMULATION_SPIKE
extern void spike_exit(int status);
    spike_exit(status);
#endif
}
 
void _init(void)
{
    /* Don't put any code here, please use _premain_init now */
}
 
void _fini(void)
{
    /* Don't put any code here, please use _postmain_fini now */
 
}
 /* End of Doxygen Group NMSIS_Core_SystemAndClock */