examples/firmware/main.c

   1 #include <stdlib.h>
   2 #include <stdint.h>
   3 #include <gram.h>
   4
   5 static inline uint32_t read32(const void *addr)
   6 {
   7         return *(volatile uint32_t *)addr;
   8 }
   9
  10 static inline void write32(void *addr, uint32_t value)
  11 {
  12         *(volatile uint32_t *)addr = value;
  13 }
  14
  15 struct uart_regs {
  16         uint32_t divisor;
  17         uint32_t rx_data;
  18         uint32_t rx_rdy;
  19         uint32_t rx_err;
  20         uint32_t tx_data;
  21         uint32_t tx_rdy;
  22         uint32_t zero0; // reserved
  23         uint32_t zero1; // reserved
  24         uint32_t ev_status;
  25         uint32_t ev_pending;
  26         uint32_t ev_enable;
  27 };
  28
  29 void uart_write(char c)
  30 {
  31         struct uart_regs *regs = 0x2000;
  32         while (!read32(&regs->tx_rdy));
  33         write32(&regs->tx_data, c);
  34 }
  35
  36 void uart_writestr(const char *c) {
  37         while (*c) {
  38                 uart_write(*c);
  39                 c++;
  40         }
  41 }
  42
  43 void memcpy(void *dest, void *src, size_t n) {
  44    int i;
  45    //cast src and dest to char*
  46    char *src_char = (char *)src;
  47    char *dest_char = (char *)dest;
  48    for (i=0; i<n; i++)
  49           dest_char[i] = src_char[i]; //copy contents byte by byte
  50 }
  51
  52 void uart_writeuint32(uint32_t val) {
  53         const char lut[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
  54         uint8_t *val_arr = &val;
  55         size_t i;
  56
  57         for (i = 0; i < 4; i++) {
  58                 uart_write(lut[(val_arr[3-i] >> 4) & 0xF]);
  59                 uart_write(lut[val_arr[3-i] & 0xF]);
  60         }
  61 }
  62
  63 void isr(void) {
  64
  65 }
  66
  67 int main(void) {
  68         const int kNumIterations = 65536;
  69         int res, failcnt = 0;
  70         uart_writestr("Firmware launched...\n");
  71
  72         uart_writestr("DRAM init... ");
  73         struct gramCtx ctx;
  74         struct gramProfile profile = {
  75                 .mode_registers = {
  76                         0x320, 0x6, 0x200, 0x0
  77                 },
  78                 .rdly_p0 = 2,
  79                 .rdly_p1 = 2,
  80         };
  81         gram_init(&ctx, &profile, (void*)0x10000000, (void*)0x00009000, (void*)0x00008000);
  82         uart_writestr("done\n");
  83
  84         uart_writestr("Auto calibrating... ");
  85         res = gram_generate_calibration(&ctx, &profile);
  86         if (res != GRAM_ERR_NONE) {
  87                 uart_writestr("failed\n");
  88                 while (1);
  89         }
  90         gram_load_calibration(&ctx, &profile);
  91         uart_writestr("done\n");
  92
  93         uart_writestr("Auto calibration profile:");
  94         uart_writestr("p0 rdly:");
  95         uart_writeuint32(profile.rdly_p0);
  96         uart_writestr(" p1 rdly:");
  97         uart_writeuint32(profile.rdly_p1);
  98         uart_writestr("\n");
  99
 100         uart_writestr("DRAM test... \n");
 101         volatile uint32_t *ram = 0x10000000;
 102         for (size_t i = 0; i < kNumIterations; i++) {
 103                 ram[i] = 0xDEAF0000 | i*4;
 104         }
 105
 106         for (size_t i = 0; i < kNumIterations; i++) {
 107                 if (ram[i] != (0xDEAF0000 | i*4)) {
 108                         uart_writestr("fail : *(0x");
 109                         uart_writeuint32(&ram[i]);
 110                         uart_writestr(") = ");
 111                         uart_writeuint32(ram[i]);
 112                         uart_write('\n');
 113                         failcnt++;
 114
 115                         if (failcnt > 10) {
 116                                 uart_writestr("Test canceled (more than 10 errors)\n");
 117                                 break;
 118                         }
 119                 }
 120         }
 121         uart_writestr("done\n");
 122
 123         while (1);
 124
 125         return 0;
 126 }