314 lines
7.2 KiB
C
314 lines
7.2 KiB
C
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <string.h>
|
|
#include "control.h"
|
|
#include "io.h"
|
|
#include "bsp_driver_sd.h"
|
|
#include "profiling.h"
|
|
|
|
// The top 4 address bits determine which device is used. (16 pages, 256 devices)
|
|
// 0xFF means that the device does not exist
|
|
// WATCH OUT THE DEVICE ADDRESS NEED TO BE REVERSED (MSB IS ON THE RIGHT)
|
|
uint8_t memory_map_0[16] = {0b00010000, 0b10001000, 0b01001000, 0b11001000, 0b00101000, 0b10101000, 0b01101000, 0b11101000, 0b00011000, 0b10011000, 0b01011000, 0b11011000, 0b00111000, 0b10111000, 0b01111000, 0b11111000};
|
|
uint8_t memory_map_1[16] = {0b00001000, 0b10001000, 0b01001000, 0b11001000, 0b00101000, 0b10101000, 0b01101000, 0b11101000, 0b00011000, 0b10011000, 0b01011000, 0b11011000, 0b00111000, 0b10111000, 0b01111000, 0b11111000};
|
|
|
|
Control control;
|
|
|
|
// @todo For some reason increasing SD_PAGES does not work
|
|
#define SD_PAGES 1
|
|
#define CPM_PAGE_SIZE 128
|
|
|
|
#define SD_PAGE_SIZE 512
|
|
#define CPM_PAGES (SD_PAGE_SIZE/CPM_PAGE_SIZE*SD_PAGES)
|
|
|
|
uint8_t get_device(uint16_t address) {
|
|
uint8_t page = address >> 12;
|
|
if (control.memory_config == 0) {
|
|
return memory_map_0[page];
|
|
} else if (control.memory_config == 1) {
|
|
return memory_map_1[page];
|
|
}
|
|
|
|
return 0xFF;
|
|
}
|
|
|
|
uint32_t calculate_lba() {
|
|
uint32_t temp = (control.storage.lba_1) + (control.storage.lba_2 << 8) + (control.storage.lba_3 << 16);
|
|
if (temp/CPM_PAGES != control.storage.lba/CPM_PAGES) {
|
|
control.storage.dirty |= 1;
|
|
}
|
|
|
|
/* printf("LBA [1]: %li\n\r", control.storage.lba_1); */
|
|
/* printf("LBA [2]: %li\n\r", control.storage.lba_2); */
|
|
/* printf("LBA [3]: %li\n\r", control.storage.lba_3); */
|
|
/* printf("LBA: %li\n\r", control.storage.lba); */
|
|
|
|
return temp;
|
|
}
|
|
|
|
void control_program_eeprom(uint8_t* data, uint16_t length) {
|
|
// Take control of the bus
|
|
printf("Taking control of bus...\n\r");
|
|
send_busrq(1);
|
|
while (!has_busak()) {
|
|
control_execute_state();
|
|
}
|
|
|
|
printf("Done!\n\r");
|
|
printf("Writing to ROM...\n\r");
|
|
|
|
enable_address_out(1);
|
|
|
|
select_device(memory_map_0[0]);
|
|
|
|
for (uint16_t i = 0; i < length; ++i) {
|
|
write_address(i);
|
|
write_data(data[i]);
|
|
|
|
enable_data_out(1);
|
|
send_memrq(1);
|
|
send_wr(1);
|
|
|
|
send_wr(0);
|
|
enable_data_out(0);
|
|
send_rd(1);
|
|
|
|
printf("%i/%i\r", i+1, length);
|
|
|
|
for (;;) {
|
|
uint8_t d = read_data();
|
|
if (d == data[i]) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
send_rd(0);
|
|
send_memrq(0);
|
|
}
|
|
|
|
enable_address_out(0);
|
|
|
|
// Release the bus again
|
|
send_busrq(0);
|
|
|
|
// Restart the z80
|
|
control_reset();
|
|
|
|
printf("\n");
|
|
}
|
|
|
|
void handle_memrq() {
|
|
uint16_t address = read_address();
|
|
uint8_t device = get_device(address);
|
|
select_device(device);
|
|
}
|
|
|
|
void handle_io_read() {
|
|
uint8_t address = read_address() & 0xFF;
|
|
|
|
switch (address) {
|
|
// @todo This should be detected on startup
|
|
// Stand in for graphics hardware
|
|
/* case 0x03: */
|
|
/* write_data(0x01); */
|
|
/* break; */
|
|
|
|
/* Stand in for the keyboard hardware */
|
|
/* case 0x1E: */
|
|
/* write_data(char_c); */
|
|
/* char_r = 0; */
|
|
/* break; */
|
|
|
|
/* Stand in for the keyboard hardware */
|
|
/* case 0x1F: */
|
|
/* #<{(| write_data(0x01 * char_r); |)}># */
|
|
/* write_data(0x00); */
|
|
/* break; */
|
|
|
|
case 0x08:
|
|
if (control.storage.ready && control.storage.action == 0x20) {
|
|
write_data(control.storage.buffer[control.storage.counter + (control.storage.lba % CPM_PAGES)*CPM_PAGE_SIZE]);
|
|
control.storage.counter++;
|
|
|
|
if (control.storage.counter >= CPM_PAGE_SIZE) {
|
|
control.storage.ready = 0;
|
|
control.storage.action = 0;
|
|
}
|
|
} else {
|
|
write_data(0x00);
|
|
}
|
|
|
|
break;
|
|
|
|
case 0x0f:
|
|
// Check if we need to read and in that case to the read
|
|
if (control.storage.action && !control.storage.ready) {
|
|
if (!control.storage.dirty || BSP_SD_ReadBlocks((uint32_t*)control.storage.buffer, control.storage.lba/CPM_PAGES, SD_PAGES, SD_DATATIMEOUT) == MSD_OK) {
|
|
// Indicate that we are ready to read/write
|
|
control.storage.ready = 1;
|
|
control.storage.dirty = 0;
|
|
} else {
|
|
// If we failed to read we will try again next time
|
|
/* printf("READ FAIL!\n\r"); */
|
|
}
|
|
}
|
|
|
|
write_data(0x08*control.storage.ready);
|
|
break;
|
|
|
|
default: {
|
|
/* uint8_t value = read_data(); */
|
|
/* #<{(| if (value == 0) { |)}># */
|
|
/* printf("IO Read: %.2X @ %.2X\n\r", value, address); */
|
|
/* #<{(| } |)}># */
|
|
return;
|
|
}
|
|
}
|
|
|
|
enable_data_out(1);
|
|
}
|
|
|
|
void handle_io_write() {
|
|
uint8_t address = read_address() & 0xFF;
|
|
uint8_t value = read_data();
|
|
|
|
switch (address) {
|
|
case 0x00:
|
|
control.memory_config = 0;
|
|
break;
|
|
|
|
case 0x01:
|
|
control.memory_config = 1;
|
|
break;
|
|
|
|
case 0x02:
|
|
printf("%c", value);
|
|
break;
|
|
|
|
case 0x08:
|
|
if (control.storage.ready && control.storage.action == 0x30) {
|
|
control.storage.buffer[control.storage.counter + (control.storage.lba % CPM_PAGES)*CPM_PAGE_SIZE] = value;
|
|
control.storage.counter++;
|
|
|
|
if (control.storage.counter >= CPM_PAGE_SIZE) {
|
|
// @todo We need to figure out some way to actually prevent write fails from occuring
|
|
if (BSP_SD_WriteBlocks((uint32_t*)control.storage.buffer, control.storage.lba/CPM_PAGES, SD_PAGES, SD_DATATIMEOUT) != MSD_OK) {
|
|
printf("WRITE FAIL!!\n\r");
|
|
}
|
|
control.storage.ready = 0;
|
|
control.storage.action = 0;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 0x0b:
|
|
control.storage.lba_1 = value;
|
|
break;
|
|
|
|
case 0x0c:
|
|
control.storage.lba_2 = value;
|
|
break;
|
|
|
|
case 0x0d:
|
|
control.storage.lba_3 = value;
|
|
break;
|
|
|
|
case 0x0f:
|
|
if (value == 0x20 || value == 0x30) {
|
|
control.storage.lba = calculate_lba();
|
|
control.storage.action = value;
|
|
control.storage.counter = 0;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
printf("IO Write: %.2X @ %.2X\n\r", value, address);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void handle_ioreq() {
|
|
if (has_wr()) {
|
|
handle_io_write();
|
|
} else if (has_rd()) {
|
|
handle_io_read();
|
|
}
|
|
}
|
|
|
|
void cycle() {
|
|
// We need this not detect IO multiple times
|
|
static uint8_t had_ioreq = 0;
|
|
if (!has_ioreq()) {
|
|
had_ioreq = 0;
|
|
}
|
|
|
|
// @todo We are forgetting to set this somewhere
|
|
enable_data_out(0);
|
|
|
|
if (has_memrq()) {
|
|
handle_memrq();
|
|
} else if (has_ioreq() && !has_m1()) {
|
|
had_ioreq++;
|
|
if (had_ioreq == 3) {
|
|
handle_ioreq();
|
|
}
|
|
} else if (has_ioreq() && has_m1()) {
|
|
printf("Interrupt ackknowledged\n\r");
|
|
}
|
|
}
|
|
|
|
void control_execute_state() {
|
|
switch (control.state) {
|
|
case CONTROL_STOP:
|
|
// OK
|
|
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_7, GPIO_PIN_RESET);
|
|
// UPDATE
|
|
HAL_GPIO_WritePin(GPIOC, GPIO_PIN_4, GPIO_PIN_RESET);
|
|
// OTHER
|
|
HAL_GPIO_WritePin(GPIOC, GPIO_PIN_5, GPIO_PIN_RESET);
|
|
return;
|
|
|
|
case CONTROL_RESET_BEGIN:
|
|
control.state++;
|
|
set_reset(1);
|
|
|
|
// OK
|
|
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_7, GPIO_PIN_SET);
|
|
// UPDATE
|
|
HAL_GPIO_WritePin(GPIOC, GPIO_PIN_4, GPIO_PIN_RESET);
|
|
// OTHER
|
|
HAL_GPIO_WritePin(GPIOC, GPIO_PIN_5, GPIO_PIN_RESET);
|
|
break;
|
|
|
|
case CONTROL_RESET_BEGIN+1 ... CONTROL_RESET_END-1:
|
|
control.state++;
|
|
set_clock(control.state % 2);
|
|
break;
|
|
|
|
case CONTROL_RESET_END:
|
|
control.state++;
|
|
set_reset(0);
|
|
break;
|
|
|
|
case CONTROL_CLOCK_LOW:
|
|
control.state++;
|
|
set_clock(1);
|
|
break;
|
|
|
|
case CONTROL_CLOCK_HIGH:
|
|
control.state--;
|
|
cycle();
|
|
set_clock(0);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// @todo Properly reset everything
|
|
void control_reset() {
|
|
free(control.storage.buffer);
|
|
Control temp = {CONTROL_RESET_BEGIN, 0, {1, 0, 0, 0, 0, 0, 0, 0, NULL}};
|
|
control = temp;
|
|
control.storage.buffer = (uint8_t*)malloc(SD_PAGES*SD_PAGE_SIZE);
|
|
}
|