Subversion Repositories potato

// The Potato Processor Benchmark Applications

// (c) Kristian Klomsten Skordal 2015 <kristian.skordal@wafflemail.net>

// Report bugs and issues on <http://opencores.org/project,potato,bugtracker>

#include <stdbool.h>

#include <stdint.h>

#include "platform.h"

#include "potato.h"

#include "gpio.h"

#include "seg7.h"

#include "sha256.h"

#include "timer.h"

#include "uart.h"

static int led_status = 0;

static volatile int hashes_per_second = 0;

// Handle an exception/interrupt.

// Arguments:

// - cause: exception cause, see potato.h for values

// - epc: exception return address

// - regbase: base of the stored context, can be used for printing all

//            registers with regbase[0] = x1 and upwards.

void exception_handler(uint32_t cause, void * epc, void * regbase)

{

        if(cause == ((1 << CAUSE_INTERRUPT_BIT) | (CAUSE_IRQ_BASE + 5))) // Timer interrupt

        {

                uart_puts(IO_ADDRESS(UART_BASE), "Hashes per second: ");

                uart_puth(IO_ADDRESS(UART_BASE), hashes_per_second);

                uart_puts(IO_ADDRESS(UART_BASE), "\n\r");

                seg7_set_value(IO_ADDRESS(SEG7_BASE), hashes_per_second);

                if(led_status == 0)

                {

                        gpio_set_output(IO_ADDRESS(GPIO2_BASE), 1);

                        led_status = 1;

                } else {

                        gpio_set_output(IO_ADDRESS(GPIO2_BASE), 0);

                        led_status = 0;

                }

                hashes_per_second = 0;

                timer_reset(IO_ADDRESS(TIMER_BASE));

        } else {

                uart_puts(IO_ADDRESS(UART_BASE), "Unhandled exception!\n\r");

                uart_puts(IO_ADDRESS(UART_BASE), "Cause: ");

                uart_puth(IO_ADDRESS(UART_BASE), cause);

                uart_puts(IO_ADDRESS(UART_BASE), "\n\r");

                uart_puts(IO_ADDRESS(UART_BASE), "EPC: ");

                uart_puth(IO_ADDRESS(UART_BASE), (uint32_t) epc);

                uart_puts(IO_ADDRESS(UART_BASE), "\n\r");

                while(1) asm volatile("nop\n");

        }

}

int main(void)

{

        // Configure GPIOs:

        gpio_set_direction(IO_ADDRESS(GPIO1_BASE), 0x0000); // Switches

        gpio_set_direction(IO_ADDRESS(GPIO2_BASE), 0xffff); // LEDs

        // Configure the 7-segment displays:

        seg7_set_enabled_displays(IO_ADDRESS(SEG7_BASE), 0xff);

        seg7_set_value(IO_ADDRESS(SEG7_BASE), 0);

        // Set up the timer:

        timer_set(IO_ADDRESS(TIMER_BASE), SYSTEM_CLK_FREQ);

        // Print a startup message:

        uart_puts(IO_ADDRESS(UART_BASE), "The Potato Processor SHA256 Benchmark\n\r\n\r");

        // Enable interrupts:

        potato_enable_irq(IRQ_TIMER);

        potato_enable_interrupts();

        struct sha256_context context;

        // Prepare a block for hashing:

        uint32_t block[16];

        uint8_t * block_ptr = (uint8_t *) block;

        block_ptr[0] = 'a';

        block_ptr[1] = 'b';

        block_ptr[2] = 'c';

        sha256_pad_le_block(block_ptr, 3, 3);

        // Repeatedly hash the same data over and over again:

        while(true)

        {

                uint8_t hash[32];

                sha256_reset(&context);

                sha256_hash_block(&context, block);

                sha256_get_hash(&context, hash);

                ++hashes_per_second;

        }

        return 0;

}