Please complete this C code with just two functions enable_interrupt() and disable_interrupt()

/* * Objective: implements a timer interrupt handler. */

#include #include #include "eecs388_lib.h"

volatile int intr_count;

#define MAX_INTERRUPTS 16 void (*interrupt_handler[MAX_INTERRUPTS])(); void (*exception_handler[MAX_INTERRUPTS])();

void handle_trap(void) __attribute((interrupt)); void handle_trap() { unsigned long mcause = read_csr(mcause); if (mcause & MCAUSE_INT) { printf("interrupt. cause=%d, count=%d ", mcause & MCAUSE_CAUSE, (int)intr_count); // mask interrupt bit and branch to handler interrupt_handler[mcause & MCAUSE_CAUSE] (); } else { printf("exception=%d ", mcause & MCAUSE_CAUSE); // synchronous exception, branch to handler exception_handler[mcause & MCAUSE_CAUSE](); } }

void timer_handler() { intr_count++;

// YOUR CODE HERE }

void enable_timer_interrupt() { write_csr(mie, read_csr(mie) | (1 << MIE_MTIE_BIT)); }

void enable_interrupt() { // YOUR CODE HERE /* Look at the enable_timer_interrupt() function for hints about how to write this function */ }

void disable_interrupt() { // YOUR CODE HERE /* Look at the enable_timer_interrupt() function for hints about how to write this function */ }

void register_trap_handler(void *func) { write_csr(mtvec, ((unsigned long)func)); }

int main (void) { int led_idx = 0; int led_gpio[] = {BLUE_LED, GREEN_LED}; for (int i = 0; i < 2; i++) gpio_mode(led_gpio[i], OUTPUT);

// install timer interrupt handler interrupt_handler[7] = timer_handler;

// write handle_trap address to mtvec register_trap_handler(handle_trap);

// enable timer interrupt enable_timer_interrupt();

// cause timer interrupt set_cycles(0);

// enable global interrupt enable_interrupt();

// main loop. int val = 0; int prev_intr_count = intr_count; while(1) { disable_interrupt(); if (prev_intr_count != intr_count) { // toggle led on/off on a new interrupt val ^= 1; gpio_write(led_gpio[led_idx], val); prev_intr_count = intr_count;

// reset counter at every 10+ interrupts if (intr_count >= 10) { printf("count=%d. reset ", (int)intr_count); intr_count = 0; gpio_write(led_gpio[led_idx], OFF); led_idx = (led_idx + 1) % 2; } } enable_interrupt(); } return 0; }

====================================================================================================

#include #include "eecs388_lib.h"

void gpio_mode(int gpio, int mode) { uint32_t val; if (mode == OUTPUT) { val = *(volatile uint32_t *) (GPIO_CTRL_ADDR + GPIO_OUTPUT_EN); val |= (1<

if (gpio == RED_LED || gpio == GREEN_LED || gpio == BLUE_LED) { // active high val = *(volatile uint32_t *) (GPIO_CTRL_ADDR + GPIO_OUTPUT_XOR); val |= (1<

void gpio_write(int gpio, int state) { uint32_t val = *(volatile uint32_t *) (GPIO_CTRL_ADDR + GPIO_OUTPUT_VAL); if (state == ON) val |= (1<

void set_cycles(uint64_t cycle) { *(volatile uint64_t *)(CLINT_CTRL_ADDR + CLINT_MTIMECMP) = cycle; }

uint64_t get_cycles(void) { return *(volatile uint64_t *)(CLINT_CTRL_ADDR + CLINT_MTIME); }

void delay(int msec) { uint64_t tend; tend = get_cycles() + msec * 32768 / 1000; while (get_cycles() < tend) {}; }

void delay_usec(int usec) { uint64_t tend; tend = get_cycles() + (uint64_t)usec * 32768 / 1000000; while (get_cycles() < tend) {}; }

void ser_init() { /* initialize UART0 TX/RX */ *(volatile uint32_t *)(UART0_CTRL_ADDR + UART_TXCTRL) |= 0x1; *(volatile uint32_t *)(UART0_CTRL_ADDR + UART_RXCTRL) |= 0x1; }

void ser_write(char c) { uint32_t regval; /* busy-wait if tx FIFO is full */ do { regval = *(volatile uint32_t *)(UART0_CTRL_ADDR + UART_TXDATA); } while (regval & 0x80000000);

/* write the character */ *(volatile uint32_t *)(UART0_CTRL_ADDR + UART_TXDATA) = c; }

void ser_printline(char *str) { int i; for (i = 0;; i++) { if (str[i] == '\0') { ser_write(' '); break; } ser_write(str[i]); } }

char ser_read() { uint32_t regval; /* busy-wait if receive FIFO is empty */ do { regval = *(volatile uint32_t *)(UART0_CTRL_ADDR + UART_RXDATA); } while (regval & 0x80000000); /* return a byte */ return (uint8_t)(regval & 0xFF); }

int ser_readline(int n, char *str) { int i = 0; for (i = 0; i < n; i++) { str[i] = ser_read(); if (str[i] == ' ') { ser_read(); /* read ' ' */ str[i] = 0; return i; } } str[i-1] = 0; return i; }

===================================================================================================

#ifndef __EECS388_LIB_H__ #define __EECS388_LIB_H__

#include

/****************************************************************************** * generic definitions *******************************************************************************/ #define ON 1 #define OFF 0 #define OUTPUT 1 #define INPUT 0

/****************************************************************************** * hifive1 platform related definitions *******************************************************************************/ #define RED_LED 22 // gpio 22 #define BLUE_LED 21 // gpio 21 #define GREEN_LED 19 // gpio 19

#define PIN_19 13 // gpio 13 /****************************************************************************** * memory map *******************************************************************************/ #define GPIO_CTRL_ADDR 0x10012000 // GPIO controller base address #define GPIO_INPUT_VAL 0x00 // input val #define GPIO_INPUT_EN 0x04 // input enable #define GPIO_OUTPUT_EN 0x08 // output enable #define GPIO_OUTPUT_VAL 0x0C // output_val #define GPIO_OUTPUT_XOR 0x40 // output XOR (invert)

#define CLINT_CTRL_ADDR 0x02000000 // CLINT block base address #define CLINT_MTIME 0xbff8 // timer register #define CLINT_MTIMECMP 0x4000 // timer compare register

#define UART0_CTRL_ADDR 0x10013000 // UART0 controller base address #define UART_TXDATA 0x00 // TXFIFO register #define UART_RXDATA 0x04 // RXFIFO register #define UART_TXCTRL 0x08 // TX control register #define UART_RXCTRL 0x0C // RX control register #define UART_IE 0x10 // interrupt enable register #define UART_IP 0x14 // interrupt pending register #define UART_DIV 0x18 // uart baud rate divisor

#define MCAUSE_INT 0x80000000UL #define MCAUSE_CAUSE 0x000003FFUL #define MSTATUS_MIE_BIT (3) // global interrupt enable bit mask. #define MIE_MTIE_BIT (7) // machine mode timer enable bit mask.

/****************************************************************************** * macros *******************************************************************************/ #define read_csr(reg) ({ unsigned long __tmp; \ asm volatile ("csrr %0, " #reg : "=r"(__tmp)); \ __tmp; })

#define write_csr(reg, val) ({ \ asm volatile ("csrw " #reg ", %0" :: "rK"(val)); })

/****************************************************************************** * eecs388 library api (similar to Arduino) *******************************************************************************/ void gpio_mode(int gpio, int mode); void gpio_write(int gpio, int state);

void set_cycles(uint64_t cycle); uint64_t get_cycles(void);

void delay(int msec); void delay_usec(int usec);

void ser_init(); void ser_write(char c); void ser_printline(char *str); char ser_read(); int ser_readline(int n, char *str);

void pwm_init(); void pwm_write(int gpio, int value); #endif // __EECS388_LIB_H__