or1k-support.h

/* Copyright (c) 2014 Authors
 *
 * Contributor Julius Baxter <julius.baxter@orsoc.se>
 * Contributor Stefan Wallentowitz <stefan.wallentowitz@tum.de>
 *
 * The authors hereby grant permission to use, copy, modify, distribute,
 * and license this software and its documentation for any purpose, provided
 * that existing copyright notices are retained in all copies and that this
 * notice is included verbatim in any distributions. No written agreement,
 * license, or royalty fee is required for any of the authorized uses.
 * Modifications to this software may be copyrighted by their authors
 * and need not follow the licensing terms described here, provided that
 * the new terms are clearly indicated on the first page of each file where
 * they apply.
 */

/* -------------------------------------------------------------------------- */
/* This program is commented throughout in a fashion suitable for processing
with Doxygen. */
/* -------------------------------------------------------------------------- */

#include <stdint.h>

#ifndef __OR1K_SUPPORT_H__
#define __OR1K_SUPPORT_H__

#define REG8(add) *((volatile unsigned char *) (add))

#define REG16(add) *((volatile unsigned short *) (add))

#define REG32(add) *((volatile unsigned long *) (add))

typedef void (*or1k_interrupt_handler_fptr)(void* data);

void or1k_interrupt_handler_add(uint32_t line,
        or1k_interrupt_handler_fptr handler,
        void* data);

void or1k_interrupt_enable(int line);

void or1k_interrupt_disable(int line);

uint32_t or1k_interrupts_disable(void);

void or1k_interrupts_enable(void);

void or1k_interrupts_restore(uint32_t status);

uint32_t or1k_critical_start();

void or1k_critical_end(uint32_t restore);
typedef void (*or1k_exception_handler_fptr)(void);

void or1k_exception_handler_add(int id, or1k_exception_handler_fptr handler);
static inline void or1k_mtspr (uint32_t spr, uint32_t value)
{
    __asm__ __volatile__ ("l.mtspr\t\t%0,%1,0": : "r" (spr), "r" (value));
}

static inline uint32_t or1k_mfspr (uint32_t spr) {
    uint32_t value;
    __asm__ __volatile__ ("l.mfspr\t\t%0,%1,0" : "=r" (value) : "r" (spr));
    return value;
}
void or1k_report (unsigned long int value);

unsigned long int or1k_rand(void);

void or1k_uart_set_read_cb(void (*cb)(char c));
void or1k_icache_enable(void);

void or1k_icache_disable(void);

void or1k_icache_flush(uint32_t entry);

void or1k_dcache_enable(void);

void or1k_dcache_disable(void);

void or1k_dcache_flush(unsigned long entry);
void or1k_immu_enable(void);

void or1k_immu_disable(void);

void or1k_dmmu_enable(void);

void or1k_dmmu_disable(void);
int or1k_timer_init(unsigned int hz);

void or1k_timer_set_period(uint32_t hz);

void or1k_timer_set_handler(void (*handler)(void));

void or1k_timer_set_mode(uint32_t mode);

void or1k_timer_enable(void);

uint32_t or1k_timer_disable(void);

void or1k_timer_restore(uint32_t sr_tee);

void or1k_timer_pause(void);

void or1k_timer_reset(void);

unsigned long or1k_timer_get_ticks(void);

void or1k_timer_reset_ticks(void);
uint32_t or1k_coreid(void);

uint32_t or1k_numcores(void);

uint32_t or1k_sync_ll(void *address);

int or1k_sync_sc(void *address, uint32_t value);

uint32_t or1k_sync_cas(void *address, uint32_t compare, uint32_t swap);

int or1k_sync_tsl(void *address);
#endif /* __NEWLIB_OR1K_SUPPORT_H__ */