mister-devel/Main_MiSTer
1
0
Fork 0
mirror of https://github.com/MiSTer-devel/Main_MiSTer.git synced 2026-04-12 03:04:02 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
80697c01b4212c5dcfbcd456ca366c09cdc378ab
Main_MiSTer/support/x86/x86.cpp

836 lines
20 KiB
C++
Raw Blame History

/*
* Copyright (c) 2014, Aleksander Osman
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <inttypes.h>
#include <stdbool.h>
#include <fcntl.h>
#include <time.h>
#include "../../spi.h"
#include "../../user_io.h"
#include "../../file_io.h"
#include "../../fpga_io.h"
#include "../../shmem.h"
#include "../../ide.h"
#include "x86_share.h"
#define FDD0_BASE 0xF200
#define FDD1_BASE 0xF300
#define RTC_BASE 0xF400
#define CFG_VER 3
#define SHMEM_ADDR 0x30000000
#define IOWR(base, reg, value) x86_dma_set((base) + (reg), value)
unsigned int hdd_table[128][3] = {
{ 306, 4, 17 }, /* 0 - 7 */
{ 615, 2, 17 },
{ 306, 4, 26 },
{ 1024, 2, 17 },
{ 697, 3, 17 },
{ 306, 8, 17 },
{ 614, 4, 17 },
{ 615, 4, 17 },
{ 670, 4, 17 }, /* 8 - 15 */
{ 697, 4, 17 },
{ 987, 3, 17 },
{ 820, 4, 17 },
{ 670, 5, 17 },
{ 697, 5, 17 },
{ 733, 5, 17 },
{ 615, 6, 17 },
{ 462, 8, 17 }, /* 016-023 */
{ 306, 8, 26 },
{ 615, 4, 26 },
{ 1024, 4, 17 },
{ 855, 5, 17 },
{ 925, 5, 17 },
{ 932, 5, 17 },
{ 1024, 2, 40 },
{ 809, 6, 17 }, /* 024-031 */
{ 976, 5, 17 },
{ 977, 5, 17 },
{ 698, 7, 17 },
{ 699, 7, 17 },
{ 981, 5, 17 },
{ 615, 8, 17 },
{ 989, 5, 17 },
{ 820, 4, 26 }, /* 032-039 */
{ 1024, 5, 17 },
{ 733, 7, 17 },
{ 754, 7, 17 },
{ 733, 5, 26 },
{ 940, 6, 17 },
{ 615, 6, 26 },
{ 462, 8, 26 },
{ 830, 7, 17 }, /* 040-047 */
{ 855, 7, 17 },
{ 751, 8, 17 },
{ 1024, 4, 26 },
{ 918, 7, 17 },
{ 925, 7, 17 },
{ 855, 5, 26 },
{ 977, 7, 17 },
{ 987, 7, 17 }, /* 048-055 */
{ 1024, 7, 17 },
{ 823, 4, 38 },
{ 925, 8, 17 },
{ 809, 6, 26 },
{ 976, 5, 26 },
{ 977, 5, 26 },
{ 698, 7, 26 },
{ 699, 7, 26 }, /* 056-063 */
{ 940, 8, 17 },
{ 615, 8, 26 },
{ 1024, 5, 26 },
{ 733, 7, 26 },
{ 1024, 8, 17 },
{ 823, 10, 17 },
{ 754, 11, 17 },
{ 830, 10, 17 }, /* 064-071 */
{ 925, 9, 17 },
{ 1224, 7, 17 },
{ 940, 6, 26 },
{ 855, 7, 26 },
{ 751, 8, 26 },
{ 1024, 9, 17 },
{ 965, 10, 17 },
{ 969, 5, 34 }, /* 072-079 */
{ 980, 10, 17 },
{ 960, 5, 35 },
{ 918, 11, 17 },
{ 1024, 10, 17 },
{ 977, 7, 26 },
{ 1024, 7, 26 },
{ 1024, 11, 17 },
{ 940, 8, 26 }, /* 080-087 */
{ 776, 8, 33 },
{ 755, 16, 17 },
{ 1024, 12, 17 },
{ 1024, 8, 26 },
{ 823, 10, 26 },
{ 830, 10, 26 },
{ 925, 9, 26 },
{ 960, 9, 26 }, /* 088-095 */
{ 1024, 13, 17 },
{ 1224, 11, 17 },
{ 900, 15, 17 },
{ 969, 7, 34 },
{ 917, 15, 17 },
{ 918, 15, 17 },
{ 1524, 4, 39 },
{ 1024, 9, 26 }, /* 096-103 */
{ 1024, 14, 17 },
{ 965, 10, 26 },
{ 980, 10, 26 },
{ 1020, 15, 17 },
{ 1023, 15, 17 },
{ 1024, 15, 17 },
{ 1024, 16, 17 },
{ 1224, 15, 17 }, /* 104-111 */
{ 755, 16, 26 },
{ 903, 8, 46 },
{ 984, 10, 34 },
{ 900, 15, 26 },
{ 917, 15, 26 },
{ 1023, 15, 26 },
{ 684, 16, 38 },
{ 1930, 4, 62 }, /* 112-119 */
{ 967, 16, 31 },
{ 1013, 10, 63 },
{ 1218, 15, 36 },
{ 654, 16, 63 },
{ 659, 16, 63 },
{ 702, 16, 63 },
{ 1002, 13, 63 },
{ 854, 16, 63 }, /* 119-127 */
{ 987, 16, 63 },
{ 995, 16, 63 },
{ 1024, 16, 63 },
{ 1036, 16, 63 },
{ 1120, 16, 59 },
{ 1054, 16, 63 },
{ 0, 0, 0 }
};
struct hddInfo {
unsigned long size;
unsigned long cylinders;
unsigned long heads;
unsigned long sectors;
};
struct hddInfo hddInfos[] = { { 0, 0, 0, 0 } };
typedef struct
{
uint32_t ver;
char img_name[6][1024];
} x86_config;
static x86_config config = {};
struct hddInfo* FindHDDInfoBySize(uint64_t size)
{
struct hddInfo* fi;
uint64_t size_chs;
bool is_chs = false;
for (int i = 0; i < 127; i++)
{
size_chs = hdd_table[i][0] * hdd_table[i][1] * hdd_table[i][2] * 512;
if (size == size_chs)
{
fi = hddInfos;
fi->size = size;
fi->cylinders = hdd_table[i][0];
fi->heads = hdd_table[i][1];
fi->sectors = hdd_table[i][2];
is_chs = true;
break;
}
}
if (!is_chs) fi = NULL;
return(fi);
}
/*
static uint32_t dma_get(uint32_t address)
{
EnableIO();
spi8(UIO_DMA_READ);
spi32w(address);
uint32_t res = spi32w(0);
DisableIO();
return res;
}
*/
static void x86_dma_set(uint32_t address, uint32_t data)
{
EnableIO();
spi8(UIO_DMA_WRITE);
spi32_w(address);
spi_w((uint16_t)data);
DisableIO();
}
static void x86_dma_sendbuf(uint32_t address, uint32_t length, uint32_t *data)
{
EnableIO();
fpga_spi_fast(UIO_DMA_WRITE);
fpga_spi_fast(address);
fpga_spi_fast(0);
if(address < FDD0_BASE) fpga_spi_fast_block_write((uint16_t*)data, length * 2);
else
{
uint8_t *buf = (uint8_t*)data;
length *= 4;
while (length--) spi_w(*buf++);
}
DisableIO();
}
static void x86_dma_recvbuf(uint32_t address, uint32_t length, uint32_t *data)
{
EnableIO();
fpga_spi_fast(UIO_DMA_READ);
fpga_spi_fast(address);
fpga_spi_fast(0);
if (address < FDD0_BASE) fpga_spi_fast_block_read((uint16_t*)data, length * 2);
else if (address == FDD0_BASE)
{
while (length--) *data++ = spi_w(0);
}
else
{
uint8_t *buf = (uint8_t*)data;
length *= 4;
while (length--) *buf++ = spi_w(0);
}
DisableIO();
}
static int mem_set(uint32_t offset, uint8_t fill_byte, uint32_t size)
{
void *buf = shmem_map(SHMEM_ADDR + offset, size);
if (!buf) return 0;
memset(buf, fill_byte, size);
shmem_unmap(buf, size);
return 1;
}
static int load_rom(const char* name, uint32_t mem_offset)
{
printf("BIOS: %s\n", name);
fileTYPE f;
if (!FileOpen(&f, name)) return 0;
uint32_t size = f.size;
void *buf = shmem_map(SHMEM_ADDR + mem_offset, size);
if (!buf)
{
FileClose(&f);
return 0;
}
memset(buf, 0, size);
FileReadAdv(&f, buf, size);
shmem_unmap(buf, size);
FileClose(&f);
return 1;
}
#define FDD_TYPE_NONE 0
#define FDD_TYPE_160 1
#define FDD_TYPE_180 2
#define FDD_TYPE_320 3
#define FDD_TYPE_360 4
#define FDD_TYPE_720 5
#define FDD_TYPE_1200 6
#define FDD_TYPE_1440 7
#define FDD_TYPE_1680 8
#define FDD_TYPE_2880 9
static char floppy_type[2] = { FDD_TYPE_NONE, FDD_TYPE_NONE };
static uint8_t get_fdd_bios_type(char type)
{
switch (type)
{
case FDD_TYPE_2880:
return 0x5;
case FDD_TYPE_1440:
case FDD_TYPE_1680:
return 0x4;
case FDD_TYPE_720:
return 0x3;
case FDD_TYPE_1200:
return 0x2;
}
return 0x1;
}
static fileTYPE fdd0_image = {};
static fileTYPE fdd1_image = {};
static fileTYPE ide_image[4] = {};
static bool boot_from_floppy = 1;
static int img_read(fileTYPE *f, uint32_t lba, void *buf, uint32_t cnt)
{
if (!FileSeekLBA(f, lba)) return 0;
return FileReadAdv(f, buf, cnt * 512);
}
static uint32_t img_write(fileTYPE *f, uint32_t lba, void *buf, uint32_t cnt)
{
if (!FileSeekLBA(f, lba)) return 0;
return FileWriteAdv(f, buf, cnt * 512);
}
static void fdd_set(int num, char* filename)
{
floppy_type[num] = FDD_TYPE_1440;
fileTYPE *fdd_image = num ? &fdd1_image : &fdd0_image;
int floppy = ide_img_mount(fdd_image, filename, 1);
uint32_t size = fdd_image->size/512;
printf("floppy size: %d blks\n", size);
if (floppy && size)
{
if (size >= 8000)
{
floppy = 0;
FileClose(fdd_image);
printf("Image size is too large for floppy. Closing...\n");
}
else if (size >= 5760) floppy_type[num] = FDD_TYPE_2880;
else if (size >= 3360) floppy_type[num] = FDD_TYPE_1680;
else if (size >= 2880) floppy_type[num] = FDD_TYPE_1440;
else if (size >= 2400) floppy_type[num] = FDD_TYPE_1200;
else if (size >= 1440) floppy_type[num] = FDD_TYPE_720;
else if (size >= 720) floppy_type[num] = FDD_TYPE_360;
else if (size >= 640) floppy_type[num] = FDD_TYPE_320;
else if (size >= 360) floppy_type[num] = FDD_TYPE_180;
else floppy_type[num] = FDD_TYPE_160;
}
else
{
floppy = 0;
}
/*
0x00.[0]: media present
0x01.[0]: media writeprotect
0x02.[7:0]: media cylinders
0x03.[7:0]: media sectors per track
0x04.[31:0]: media total sector count
0x05.[1:0]: media heads
0x06.[31:0]: media sd base
0x07.[15:0]: media wait cycles: 200000 us / spt
0x08.[15:0]: media wait rate 0: 1000 us
0x09.[15:0]: media wait rate 1: 1666 us
0x0A.[15:0]: media wait rate 2: 2000 us
0x0B.[15:0]: media wait rate 3: 500 us
0x0C.[7:0]: media type: 8'h20 none; 8'h00 old; 8'hC0 720k; 8'h80 1_44M; 8'h40 2_88M
*/
int floppy_spt = 0;
int floppy_cylinders = 0;
int floppy_heads = 0;
switch (floppy_type[num])
{
case FDD_TYPE_160: floppy_spt = 8; floppy_cylinders = 40; floppy_heads = 1; break;
case FDD_TYPE_180: floppy_spt = 9; floppy_cylinders = 40; floppy_heads = 1; break;
case FDD_TYPE_320: floppy_spt = 8; floppy_cylinders = 40; floppy_heads = 2; break;
case FDD_TYPE_360: floppy_spt = 9; floppy_cylinders = 40; floppy_heads = 2; break;
case FDD_TYPE_720: floppy_spt = 9; floppy_cylinders = 80; floppy_heads = 2; break;
case FDD_TYPE_1200: floppy_spt = 15; floppy_cylinders = 80; floppy_heads = 2; break;
case FDD_TYPE_1440: floppy_spt = 18; floppy_cylinders = 80; floppy_heads = 2; break;
case FDD_TYPE_1680: floppy_spt = 21; floppy_cylinders = 80; floppy_heads = 2; break;
case FDD_TYPE_2880: floppy_spt = 36; floppy_cylinders = 80; floppy_heads = 2; break;
}
int floppy_total_sectors = floppy_spt * floppy_heads * floppy_cylinders;
printf("floppy:\n");
printf(" cylinders: %d\n", floppy_cylinders);
printf(" heads: %d\n", floppy_heads);
printf(" spt: %d\n", floppy_spt);
printf(" total_sectors: %d\n\n", floppy_total_sectors);
uint32_t subaddr = num << 7;
IOWR(FDD0_BASE + subaddr, 0x0, 0); // Always eject floppy before insertion
usleep(100000);
IOWR(FDD0_BASE + subaddr, 0x0, floppy ? 1 : 0);
IOWR(FDD0_BASE + subaddr, 0x1, (floppy && (fdd_image->mode & O_RDWR)) ? 0 : 1);
IOWR(FDD0_BASE + subaddr, 0x2, floppy_cylinders);
IOWR(FDD0_BASE + subaddr, 0x3, floppy_spt);
IOWR(FDD0_BASE + subaddr, 0x4, floppy_total_sectors);
IOWR(FDD0_BASE + subaddr, 0x5, floppy_heads);
IOWR(FDD0_BASE + subaddr, 0x6, 0); // base LBA
IOWR(FDD0_BASE + subaddr, 0xC, 0);
}
static void hdd_set(int num, char* filename)
{
int present = 0;
int cd = 0;
int len = strlen(filename);
int vhd = (len > 4 && !strcasecmp(filename + len - 4, ".vhd"));
if (num > 1 && !vhd)
{
const char *img_name = cdrom_parse(num, filename);
if (img_name) present = ide_img_mount(&ide_image[num], img_name, 0);
if (present) cd = 1;
}
if(!present && vhd) present = ide_img_mount(&ide_image[num], filename, 1);
if (!cd && is_pcxt())
{
FILE* fd;
uint64_t size;
struct hddInfo* hdd_fi;
const char* path = getFullPath(filename);
fd = fopen(path, "r");
if (fd)
{
fseek(fd, 0L, SEEK_END);
size = ftello64(fd);
if ((hdd_fi = FindHDDInfoBySize(size)))
{
ide_img_set(num, present ? &ide_image[num] : 0, cd, hdd_fi->sectors, hdd_fi->heads);
}
else
{
if (size > 8455200768ULL) // 16383 cylinders * 16 heads * 63 sectors * 512 bytes per sector (Max. CHS)
{
ide_img_set(num, present ? &ide_image[num] : 0, cd);
}
else
{
ide_img_set(num, present ? &ide_image[num] : 0, cd, 63, 16);
}
}
}
}
else
{
ide_img_set(num, present ? &ide_image[num] : 0, cd);
}
}
static uint8_t bin2bcd(unsigned val)
{
return ((val / 10) << 4) + (val % 10);
}
void x86_ide_set()
{
for (int i = 0; i < 4; i++) hdd_set(i, config.img_name[i + 2]);
}
void x86_init()
{
user_io_status_set("[0]", 1);
const char *home = HomeDir();
if (is_x86())
{
// PC-DOS/MS-DOS/Win3.x/Win9x recognize 0xFF as free memory (UMA),
// otherwise it can be incorrectly interpreted as used by Option RAM (non-free).
mem_set(0xA0000, 0xFF, 0x60000); // Fill UMA (640 kb - 1 Mb) with 0xFF
mem_set(0xA0000, 0x00, 0x20000); // Clear Video RAM
mem_set(0xCE000, 0x00, 0x2000); // Clear shr_rgn
load_rom(user_io_make_filepath(home, "boot1.rom"), 0xC0000); // Video BIOS ROM
load_rom(user_io_make_filepath(home, "boot0.rom"), 0xF0000); // BIOS ROM
}
uint16_t cfg = ide_check();
uint8_t hotswap[4] = {
0,
0,
(uint8_t)(((cfg >> 8) & 1) ^ 1),
(uint8_t)((cfg >> 9) & 1),
};
ide_reset(hotswap);
fdd_set(0, config.img_name[0]);
fdd_set(1, config.img_name[1]);
for (int i = 0; i < 4; i++) hdd_set(i, config.img_name[i + 2]);
//-------------------------------------------------------------------------- rtc
// memcfg 0: 256MB
// memcfg 1: 16MB
uint8_t memcfg = is_x86() ? user_io_status_get("[11]") : 1;
unsigned char translate_mode = 1; //LBA
translate_mode = (translate_mode << 6) | (translate_mode << 4) | (translate_mode << 2) | translate_mode;
time_t t = time(NULL);
struct tm tm = *localtime(&t);
//rtc contents 0-127
uint8_t cmos[128] =
{
bin2bcd(tm.tm_sec), //0x00: SEC BCD
0x00, //0x01: ALARM SEC BCD
bin2bcd(tm.tm_min), //0x02: MIN BCD
0x00, //0x03: ALARM MIN BCD
bin2bcd(tm.tm_hour), //0x04: HOUR BCD 24h
0x12, //0x05: ALARM HOUR BCD 24h
(uint8_t)(tm.tm_wday + 1), //0x06: DAY OF WEEK Sunday=1
bin2bcd(tm.tm_mday), //0x07: DAY OF MONTH BCD from 1
bin2bcd(tm.tm_mon + 1), //0x08: MONTH BCD from 1
bin2bcd((tm.tm_year < 117) ? 17 : tm.tm_year - 100), //0x09: YEAR BCD
0x26, //0x0A: REG A
0x02, //0x0B: REG B
0x00, //0x0C: REG C
0x80, //0x0D: REG D
0x00, //0x0E: REG E - POST status
0x00, //0x0F: REG F - shutdown status
(uint8_t)((get_fdd_bios_type(floppy_type[0])<<4) | get_fdd_bios_type(floppy_type[1])),
0x00, //0x11: configuration bits; not used
0x00, //0x12: hard disk types; 0-none, 1:E-type, F-type 16+ (unused)
0x00, //0x13: advanced configuration bits; not used
0x4D, //0x14: equipment bits
0x80, //0x15: base memory in 1k LSB
0x02, //0x16: base memory in 1k MSB
0x00, //0x17: memory size above 1m in 1k LSB
(uint8_t)(memcfg ? 0x3C : 0xFC), //0x18: memory size above 1m in 1k MSB
0x00, //0x19: extended hd types 1/2; type 47d (unused)
0x00, //0x1A: extended hd types 2/2 (unused)
//these hd parameters aren't used anymore
0x00, //0x1B: hd 0 configuration 1/9; cylinders low
0x00, //0x1C: hd 0 configuration 2/9; cylinders high
0x00, //0x1D: hd 0 configuration 3/9; heads
0x00, //0x1E: hd 0 configuration 4/9; write pre-comp low
0x00, //0x1F: hd 0 configuration 5/9; write pre-comp high
0x00, //0x20: hd 0 configuration 6/9; retries/bad map/heads>8
0x00, //0x21: hd 0 configuration 7/9; landing zone low
0x00, //0x22: hd 0 configuration 8/9; landing zone high
0x00, //0x23: hd 0 configuration 9/9; sectors/track
0x00, //0x24: hd 1 configuration 1/9; cylinders low
0x00, //0x25: hd 1 configuration 2/9; cylinders high
0x00, //0x26: hd 1 configuration 3/9; heads
0x00, //0x27: hd 1 configuration 4/9; write pre-comp low
0x00, //0x28: hd 1 configuration 5/9; write pre-comp high
0x00, //0x29: hd 1 configuration 6/9; retries/bad map/heads>8
0x00, //0x2A: hd 1 configuration 7/9; landing zone low
0x00, //0x2B: hd 1 configuration 8/9; landing zone high
0x00, //0x2C: hd 1 configuration 9/9; sectors/track
(uint8_t)((fdd0_image.size && boot_from_floppy) ? 0x20 : 0x00), //0x2D: boot sequence
0x00, //0x2E: checksum MSB
0x00, //0x2F: checksum LSB
0x00, //0x30: memory size above 1m in 1k LSB
(uint8_t)(memcfg ? 0x3C : 0xFC), //0x31: memory size above 1m in 1k MSB
0x20, //0x32: IBM century
0x00, //0x33: ?
(uint8_t)(memcfg ? 0x00 : 0x80), //0x34: memory size above 16m in 64k LSB
(uint8_t)(memcfg ? 0x00 : 0x0E), //0x35: memory size above 16m in 64k MSB; 256-8 MB
0x00, //0x36: ?
0x20, //0x37: IBM PS/2 century
0x00, //0x38: eltorito boot sequence; not used
translate_mode, //0x39: ata translation policy 1-4
0x00, //0x3A: ata translation policy 5-8
0x00, //0x3B: ?
0x00, //0x3C: ?
(uint8_t)((fdd0_image.size && boot_from_floppy) ? 0x21 : 0x02), //0x3D: eltorito boot sequence
0x00, //0x3E: ?
0x00, //0x3F: ?
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
//count checksum
unsigned short sum = 0;
for (int i = 0x10; i <= 0x2D; i++) sum += cmos[i];
cmos[0x2E] = sum >> 8;
cmos[0x2F] = sum & 0xFF;
for (unsigned int i = 0; i < sizeof(cmos) / sizeof(cmos[0]); i++) IOWR(RTC_BASE, i, cmos[i]);
x86_share_reset();
user_io_status_set("[0]", 0);
}
static void fdd_io(uint8_t read)
{
fileTYPE *img = &fdd0_image;
struct sd_param_t
{
uint32_t lba;
uint32_t cnt;
};
static struct sd_param_t sd_params = {};
static uint32_t secbuf[128 * 16];
x86_dma_recvbuf(FDD0_BASE, sizeof(sd_params) >> 2, (uint32_t*)&sd_params);
if (sd_params.lba >> 15)
{
// Floppy B:
sd_params.lba &= 0x7FFF;
img = &fdd1_image;
}
int res = 0;
if (read)
{
//printf("Read: 0x%08x, %d, %d\n", basereg, sd_params.lba, sd_params.cnt);
if (img->size)
{
if (img_read(img, sd_params.lba, &secbuf, 1))
{
x86_dma_sendbuf(FDD0_BASE + 255, 128, secbuf);
res = 1;
}
}
else
{
printf("Error: image is not ready.\n");
}
if (!res)
{
memset(secbuf, 0, 512);
x86_dma_sendbuf(FDD0_BASE + 255, 128, secbuf);
}
}
else
{
//printf("Write: 0x%08x, 0x%08x, %d\n", basereg, sd_params.lba, sd_params.cnt);
x86_dma_recvbuf(FDD0_BASE + 255, sd_params.cnt * 128, secbuf);
if (img->size)
{
if (sd_params.cnt > 0 && sd_params.cnt <= 16)
{
if (img->mode & O_RDWR)
{
if (img_write(img, sd_params.lba, secbuf, sd_params.cnt))
{
res = 1;
}
}
else
{
printf("Error: image is read-only.\n");
}
}
else
{
printf("Error: Block count %d is out of range 1..16.\n", sd_params.cnt);
}
}
else
{
printf("Error: image is not ready.\n");
}
}
}
void x86_poll(int only_ide)
{
if(!only_ide) x86_share_poll();
uint16_t sd_req = ide_check();
if (sd_req)
{
if (sd_req & 0x400) ide_cdda_send_sector();
ide_io(0, sd_req & 7);
sd_req >>= 3;
ide_io(1, sd_req & 7);
sd_req >>= 3;
if (!only_ide && (sd_req & 3)) fdd_io(sd_req & 1);
}
}
void x86_set_image(int num, char *filename)
{
memset(config.img_name[num], 0, sizeof(config.img_name[0]));
strcpy(config.img_name[num], filename);
if (num < 2) fdd_set(num, filename);
else if (ide_is_placeholder(num - 2)) hdd_set(num - 2, filename);
}
static char* get_config_name()
{
static char str[256];
snprintf(str, sizeof(str), "%ssys.cfg", user_io_get_core_name());
return str;
}
void x86_config_save()
{
config.ver = CFG_VER;
FileSaveConfig(get_config_name(), &config, sizeof(config));
}
void x86_config_load()
{
static x86_config tmp;
memset(&config, 0, sizeof(config));
if (FileLoadConfig(get_config_name(), &tmp, sizeof(tmp)) && (tmp.ver == CFG_VER))
{
memcpy(&config, &tmp, sizeof(config));
}
}
void x86_set_fdd_boot(uint32_t boot)
{
boot_from_floppy = (boot != 0);
}
const char* x86_get_image_name(int num)
{
static char res[32];
char *name = config.img_name[num];
if (!name[0]) return NULL;
char *p = strrchr(name, '/');
if (!p) p = name;
else p++;
if (strlen(p) < 19) strcpy(res, p);
else
{
strncpy(res, p, 19);
res[19] = 0;
}
return res;
}
const char* x86_get_image_path(int num)
{
return config.img_name[num];
}
Reference in New Issue View Git Blame Copy Permalink