git.sesse.net Git - pistorm/blob - buptest.c

   1 #include <assert.h>
   2 #include <dirent.h>
   3 #include <endian.h>
   4 #include <fcntl.h>
   5 #include <pthread.h>
   6 #include <sched.h>
   7 #include <signal.h>
   8 #include <stdint.h>
   9 #include <stdio.h>
  10 #include <time.h>
  11 #include <stdlib.h>
  12 #include <string.h>
  13 #include <sys/mman.h>
  14 #include <sys/stat.h>
  15 #include <sys/types.h>
  16 #include <unistd.h>
  17 #include <sys/ioctl.h>
  18 #include "main.h"
  19 #include "gpio/gpio.h"
  20 #include "platforms/amiga/gayle-ide/ide.h"
  21
  22 uint8_t garbege_datas[2 * 1024 * 1024];
  23
  24 struct timespec f2;
  25
  26 uint8_t gayle_int;
  27 uint32_t mem_fd;
  28 uint32_t errors = 0;
  29
  30 void sigint_handler(int sig_num) {
  31   //if (sig_num) { }
  32   //cpu_emulation_running = 0;
  33
  34   //return;
  35   printf("Received sigint %d, exiting.\n", sig_num);
  36   if (mem_fd)
  37     close(mem_fd);
  38
  39   exit(0);
  40 }
  41
  42 int main() {
  43     clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &f2);
  44     srand((unsigned int)f2.tv_nsec);
  45
  46     signal(SIGINT, sigint_handler);
  47     setup_io();
  48
  49     printf("Enable 200MHz GPCLK0 on GPIO4\n");
  50     gpio_enable_200mhz();
  51
  52     write_reg(0x01);
  53     usleep(100);
  54     usleep(1500);
  55     write_reg(0x00);
  56     usleep(100);
  57
  58     usleep(1500);
  59
  60     write_reg(0x00);
  61     // printf("Status Reg%x\n",read_reg());
  62     usleep(100000);
  63     write_reg(0x02);
  64     usleep(1500);
  65
  66     write8(0xbfe201, 0x0101);       //CIA OVL
  67         write8(0xbfe001, 0x0000);       //CIA OVL LOW
  68
  69     printf("Writing garbege datas.\n");
  70     for (uint32_t i = 0; i < 512 * 1024; i++) {
  71         while(garbege_datas[i] == 0x00)
  72             garbege_datas[i] = (uint8_t)(rand() % 0xFF);
  73         write8(i, (uint32_t)garbege_datas[i]);
  74     }
  75
  76     printf("Reading back garbege datas, read8()...\n");
  77     for (uint32_t i = 0; i < 512 * 1024; i++) {
  78         uint32_t c = read8(i);
  79         if (c != garbege_datas[i]) {
  80             if (errors < 512)
  81                 printf("READ8: Garbege data mismatch at $%.6X: %.2X should be %.2X.\n", i, c, garbege_datas[i]);
  82             errors++;
  83         }
  84     }
  85     printf("read8 errors total: %d.\n", errors);
  86     errors = 0;
  87     sleep (1);
  88
  89     printf("Reading back garbege datas, read16(), even addresses...\n");
  90     for (uint32_t i = 0; i < (512 * 1024) - 2; i += 2) {
  91         uint32_t c = be16toh(read16(i));
  92         if (c != *((uint16_t *)&garbege_datas[i])) {
  93             if (errors < 512)
  94                 printf("READ16_EVEN: Garbege data mismatch at $%.6X: %.4X should be %.4X.\n", i, c, *((uint16_t *)&garbege_datas[i]));
  95             errors++;
  96         }
  97     }
  98     printf("read16 even errors total: %d.\n", errors);
  99     errors = 0;
 100     sleep (1);
 101
 102     printf("Reading back garbege datas, read16(), odd addresses...\n");
 103     for (uint32_t i = 1; i < (512 * 1024) - 2; i += 2) {
 104         uint32_t c = be16toh((read8(i) << 8) | read8(i + 1));
 105         if (c != *((uint16_t *)&garbege_datas[i])) {
 106             if (errors < 512)
 107                 printf("READ16_ODD: Garbege data mismatch at $%.6X: %.4X should be %.4X.\n", i, c, *((uint16_t *)&garbege_datas[i]));
 108             errors++;
 109         }
 110     }
 111     printf("read16 odd errors total: %d.\n", errors);
 112     errors = 0;
 113     sleep (1);
 114
 115     printf("Reading back garbege datas, read32(), even addresses...\n");
 116     for (uint32_t i = 0; i < (512 * 1024) - 4; i += 2) {
 117         uint32_t c = be32toh(read32(i));
 118         if (c != *((uint32_t *)&garbege_datas[i])) {
 119             if (errors < 512)
 120                 printf("READ32_EVEN: Garbege data mismatch at $%.6X: %.8X should be %.8X.\n", i, c, *((uint32_t *)&garbege_datas[i]));
 121             errors++;
 122         }
 123     }
 124     printf("read32 even errors total: %d.\n", errors);
 125     errors = 0;
 126     sleep (1);
 127
 128     printf("Reading back garbege datas, read32(), odd addresses...\n");
 129     for (uint32_t i = 1; i < (512 * 1024) - 4; i += 2) {
 130         uint32_t c = read8(i);
 131         c |= (be16toh(read16(i + 1)) << 8);
 132         c |= (read8(i + 3) << 24);
 133         //c = be32toh(c);
 134         if (c != *((uint32_t *)&garbege_datas[i])) {
 135             if (errors < 512)
 136                 printf("READ32_ODD: Garbege data mismatch at $%.6X: %.8X should be %.8X.\n", i, c, *((uint32_t *)&garbege_datas[i]));
 137             errors++;
 138         }
 139     }
 140     printf("read32 odd errors total: %d.\n", errors);
 141     errors = 0;
 142     sleep (1);
 143
 144     printf("Clearing 512KB of Chip again\n");
 145     for (uint32_t i = 0; i < 512 * 1024; i++) {
 146         write8(i, (uint32_t)0x0);
 147     }
 148
 149     printf("[WORD] Writing garbege datas to Chip, unaligned...\n");
 150     for (uint32_t i = 1; i < (512 * 1024) - 2; i += 2) {
 151         uint16_t v = *((uint16_t *)&garbege_datas[i]);
 152         write8(i, (v & 0x00FF));
 153         write8(i + 1, (v >> 8));
 154         //write16(i, *((uint16_t *)&garbege_datas[i]));
 155     }
 156
 157     sleep (1);
 158     printf("Reading back garbege datas, read16(), odd addresses...\n");
 159     for (uint32_t i = 1; i < (512 * 1024) - 2; i += 2) {
 160         //uint32_t c = be16toh(read16(i));
 161         uint32_t c = be16toh((read8(i) << 8) | read8(i + 1));
 162         if (c != *((uint16_t *)&garbege_datas[i])) {
 163             if (errors < 512)
 164                 printf("READ16_EVEN: Garbege data mismatch at $%.6X: %.4X should be %.4X.\n", i, c, *((uint16_t *)&garbege_datas[i]));
 165             errors++;
 166         }
 167     }
 168     printf("read16 even errors total: %d.\n", errors);
 169     errors = 0;
 170
 171     printf("Clearing 512KB of Chip again\n");
 172     for (uint32_t i = 0; i < 512 * 1024; i++) {
 173         write8(i, (uint32_t)0x0);
 174     }
 175
 176     printf("[LONG] Writing garbege datas to Chip, unaligned...\n");
 177     for (uint32_t i = 1; i < (512 * 1024) - 4; i += 4) {
 178         uint32_t v = *((uint32_t *)&garbege_datas[i]);
 179         write8(i , v & 0x0000FF);
 180         write16(i + 1, htobe16(((v & 0x00FFFF00) >> 8)));
 181         write8(i + 3 , (v & 0xFF000000) >> 24);
 182         //write32(i, v);
 183     }
 184
 185     sleep (1);
 186     printf("Reading back garbege datas, read32(), even addresses...\n");
 187     for (uint32_t i = 1; i < (512 * 1024) - 4; i += 4) {
 188         uint32_t c = read8(i);
 189         c |= (be16toh(read16(i + 1)) << 8);
 190         c |= (read8(i + 3) << 24);
 191         //uint32_t c = be32toh(read32(i));
 192         if (c != *((uint32_t *)&garbege_datas[i])) {
 193             if (errors < 512)
 194                 printf("READ32_EVEN: Garbege data mismatch at $%.6X: %.8X should be %.8X.\n", i, c, *((uint32_t *)&garbege_datas[i]));
 195             errors++;
 196         }
 197     }
 198     printf("read32 even errors total: %d.\n", errors);
 199     errors = 0;
 200
 201     return 0;
 202 }
 203
 204 void m68k_set_irq(unsigned int level) {
 205 }
 206
 207 struct ide_controller *get_ide(int index) {
 208     return NULL;
 209 }