mirror/86Box
1
0
Fork 0
mirror of https://github.com/86Box/86Box.git synced 2026-02-22 01:25:33 -07:00
Code Issues Packages Projects Releases Activity

Merge branch '86Box:master' into machine_23

Browse Source
This commit is contained in:
BurnedPinguin
2023-07-26 12:27:53 +02:00
committed by GitHub
parent 908b9b1974 937cadf054
commit e12ed7272c
297 changed files with 7497 additions and 4915 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
README.md
View File

@@ -1,11 +1,13 @@
86Box
=====
[![Build Status](https://ci.86box.net/job/86Box/badge/icon)](https://ci.86box.net/job/86Box/)
**86Box** is a low level x86 emulator that runs older operating systems and software designed for IBM PC systems and compatibles from 1981 through fairly recent system designs based on the PCI bus.
Features
--------
* Easy to use interface inspired by mainstream hypervisor software
* Low level emulation of 8086-based processors up to the Mendocino-era Celeron with focus on accuracy
* Great range of customizability of virtual machines
@@ -16,6 +18,7 @@ Features
Minimum system requirements and recommendations
-----------------------------------------------
* Intel Core 2 or AMD Athlon 64 processor or newer
* Windows version: Windows 7 Service Pack 1 or later
* Linux version: Ubuntu 16.04, Debian 9.0 or other distributions from 2016 onwards
@@ -25,6 +28,7 @@ Minimum system requirements and recommendations
Performance may vary depending on both host and guest configuration. Most emulation logic is executed in a single thread; therefore, systems with better IPC (instructions per clock) generally should be able to emulate higher clock speeds.
It is also recommended to use a manager application with 86Box for easier handling of multiple virtual machines.
* [86Box Manager](https://github.com/86Box/86BoxManager) by [Overdoze](https://github.com/daviunic) (Windows only)
* [86Box Manager Lite](https://github.com/insanemal/86box_manager_py) by [Insanemal](https://github.com/insanemal)
* [WinBox for 86Box](https://github.com/86Box/WinBox-for-86Box) by Laci bá' (Windows only)
@@ -35,10 +39,12 @@ It is also possible to use 86Box on its own with the `--vmpath`/`-P` command lin
Getting started
---------------
See [our documentation](https://86box.readthedocs.io/en/latest/index.html) for an overview of the emulator's features and user interface.
Community
---------
We operate an IRC channel and a Discord server for discussing 86Box, its development and anything related to retro computing. We look forward to hearing from you!
[![Visit our IRC channel](https://kiwiirc.com/buttons/irc.ringoflightning.net/86Box.png)](https://kiwiirc.com/client/irc.ringoflightning.net/?nick=86box|?#86Box)
@@ -47,16 +53,19 @@ We operate an IRC channel and a Discord server for discussing 86Box, its develop
Contributions
---------
We welcome all contributions to the project, as long as the [contribution guidelines](CONTRIBUTING.md) are followed.
Licensing
---------
86Box is released under the [GNU General Public License, version 2](https://www.gnu.org/licenses/old-licenses/gpl-2.0.html) or later. For more information, see the `COPYING` file in the root of the repository.
The emulator can also optionally make use of [munt](https://github.com/munt/munt), [FluidSynth](https://www.fluidsynth.org/), [Ghostscript](https://www.ghostscript.com/) and [Discord Game SDK](https://discord.com/developers/docs/game-sdk/sdk-starter-guide), which are distributed under their respective licenses.
Donations
---------
We do not charge you for the emulator but donations are still welcome:
https://paypal.me/86Box.

32
src/86box.c
View File

@@ -408,18 +408,18 @@ pc_log(const char *fmt, ...)
int
pc_init(int argc, char *argv[])
{
char *ppath = NULL;
char *rpath = NULL;
char *cfg = NULL;
char *p;
char temp[2048];
char *fn[FDD_NUM] = { NULL };
char drive = 0;
char *temp2 = NULL;
struct tm *info;
time_t now;
int c;
int lvmp = 0;
char *ppath = NULL;
char *rpath = NULL;
char *cfg = NULL;
char *p;
char temp[2048];
char *fn[FDD_NUM] = { NULL };
char drive = 0;
char *temp2 = NULL;
const struct tm *info;
time_t now;
int c;
int lvmp = 0;
#ifdef ENABLE_NG
int ng = 0;
#endif
@@ -1144,9 +1144,9 @@ pc_reset_hard_init(void)
void
update_mouse_msg(void)
{
wchar_t wcpufamily[2048];
wchar_t wcpu[2048];
wchar_t wmachine[2048];
wchar_t wcpufamily[2048];
wchar_t wcpu[2048];
wchar_t wmachine[2048];
wchar_t *wcp;
mbstowcs(wmachine, machine_getname(), strlen(machine_getname()) + 1);
@@ -1185,7 +1185,7 @@ pc_reset_hard(void)
}
void
pc_close(thread_t *ptr)
pc_close(UNUSED(thread_t *ptr))
{
/* Wait a while so things can shut down. */
plat_delay_ms(200);

52
src/acpi.c
View File

@@ -226,10 +226,10 @@ acpi_reg_read_common_regs(UNUSED(int size), uint16_t addr, void *priv)
static uint32_t
acpi_reg_read_ali(int size, uint16_t addr, void *priv)
{
acpi_t *dev = (acpi_t *) priv;
uint32_t ret = 0x00000000;
int shift16;
int shift32;
const acpi_t *dev = (acpi_t *) priv;
uint32_t ret = 0x00000000;
int shift16;
int shift32;
addr &= 0x3f;
shift16 = (addr & 1) << 3;
@@ -294,10 +294,10 @@ acpi_reg_read_ali(int size, uint16_t addr, void *priv)
static uint32_t
acpi_reg_read_intel(int size, uint16_t addr, void *priv)
{
acpi_t *dev = (acpi_t *) priv;
uint32_t ret = 0x00000000;
int shift16;
int shift32;
const acpi_t *dev = (acpi_t *) priv;
uint32_t ret = 0x00000000;
int shift16;
int shift32;
addr &= 0x3f;
shift16 = (addr & 1) << 3;
@@ -391,10 +391,10 @@ acpi_reg_read_intel(int size, uint16_t addr, void *priv)
static uint32_t
acpi_reg_read_via_common(int size, uint16_t addr, void *priv)
{
acpi_t *dev = (acpi_t *) priv;
uint32_t ret = 0x00000000;
int shift16;
int shift32;
const acpi_t *dev = (acpi_t *) priv;
uint32_t ret = 0x00000000;
int shift16;
int shift32;
addr &= 0xff;
shift16 = (addr & 1) << 3;
@@ -544,10 +544,10 @@ acpi_reg_read_via(int size, uint16_t addr, void *priv)
static uint32_t
acpi_reg_read_via_596b(int size, uint16_t addr, void *priv)
{
acpi_t *dev = (acpi_t *) priv;
uint32_t ret = 0x00000000;
int shift16;
int shift32;
const acpi_t *dev = (acpi_t *) priv;
uint32_t ret = 0x00000000;
int shift16;
int shift32;
addr &= 0x7f;
shift16 = (addr & 1) << 3;
@@ -610,9 +610,9 @@ acpi_reg_read_smc(int size, uint16_t addr, void *priv)
static uint32_t
acpi_aux_reg_read_smc(UNUSED(int size), uint16_t addr, void *priv)
{
acpi_t *dev = (acpi_t *) priv;
uint32_t ret = 0x00000000;
int shift16;
const acpi_t *dev = (acpi_t *) priv;
uint32_t ret = 0x00000000;
int shift16;
addr &= 0x07;
shift16 = (addr & 1) << 3;
@@ -1189,7 +1189,7 @@ acpi_aux_reg_write_smc(UNUSED(int size), uint16_t addr, uint8_t val, void *priv)
static uint32_t
acpi_reg_read_common(int size, uint16_t addr, void *priv)
{
acpi_t *dev = (acpi_t *) priv;
const acpi_t *dev = (acpi_t *) priv;
uint8_t ret = 0xff;
if (dev->vendor == VEN_ALI)
@@ -1209,7 +1209,7 @@ acpi_reg_read_common(int size, uint16_t addr, void *priv)
static void
acpi_reg_write_common(int size, uint16_t addr, uint8_t val, void *priv)
{
acpi_t *dev = (acpi_t *) priv;
const acpi_t *dev = (acpi_t *) priv;
if (dev->vendor == VEN_ALI)
acpi_reg_write_ali(size, addr, val, priv);
@@ -1226,7 +1226,7 @@ acpi_reg_write_common(int size, uint16_t addr, uint8_t val, void *priv)
static uint32_t
acpi_aux_reg_read_common(int size, uint16_t addr, void *priv)
{
acpi_t *dev = (acpi_t *) priv;
const acpi_t *dev = (acpi_t *) priv;
uint8_t ret = 0xff;
if (dev->vendor == VEN_SMC)
@@ -1238,7 +1238,7 @@ acpi_aux_reg_read_common(int size, uint16_t addr, void *priv)
static void
acpi_aux_reg_write_common(int size, uint16_t addr, uint8_t val, void *priv)
{
acpi_t *dev = (acpi_t *) priv;
const acpi_t *dev = (acpi_t *) priv;
if (dev->vendor == VEN_SMC)
acpi_aux_reg_write_smc(size, addr, val, priv);
@@ -1591,8 +1591,8 @@ acpi_apm_out(uint16_t port, uint8_t val, void *priv)
static uint8_t
acpi_apm_in(uint16_t port, void *priv)
{
acpi_t *dev = (acpi_t *) priv;
uint8_t ret = 0xff;
const acpi_t *dev = (acpi_t *) priv;
uint8_t ret = 0xff;
port &= 0x0001;
@@ -1694,7 +1694,7 @@ acpi_init(const device_t *info)
dev = (acpi_t *) malloc(sizeof(acpi_t));
if (dev == NULL)
return (NULL);
return NULL;
memset(dev, 0x00, sizeof(acpi_t));
cpu_to_acpi = ACPI_TIMER_FREQ / cpuclock;

9
src/apm.c
View File

@@ -71,8 +71,8 @@ apm_out(uint16_t port, uint8_t val, void *priv)
static uint8_t
apm_in(uint16_t port, void *priv)
{
apm_t *dev = (apm_t *) priv;
uint8_t ret = 0xff;
const apm_t *dev = (apm_t *) priv;
uint8_t ret = 0xff;
port &= 0x0001;
@@ -102,9 +102,8 @@ apm_close(void *priv)
free(dev);
}
static void
*
apm_init(const device_t *info)
static void *
apm_init(const device_t *info)
{
apm_t *dev = (apm_t *) malloc(sizeof(apm_t));
memset(dev, 0, sizeof(apm_t));

2
src/cdrom/cdrom.c
View File

@@ -163,7 +163,7 @@ cdrom_interface_get_from_internal_name(char *s)
int c = 0;
while (controllers[c].device != NULL) {
if (!strcmp((char *) controllers[c].device->internal_name, s))
if (!strcmp(controllers[c].device->internal_name, s))
return c;
c++;
}

34
src/cdrom/cdrom_image_backend.c
View File

@@ -202,7 +202,7 @@ track_file_close(track_t *trk)
static void
cdi_clear_tracks(cd_img_t *cdi)
{
track_file_t *last = NULL;
const track_file_t *last = NULL;
track_t *cur = NULL;
if ((cdi->tracks == NULL) || (cdi->tracks_num == 0))
@@ -273,7 +273,7 @@ cdi_get_audio_tracks_lba(cd_img_t *cdi, int *st_track, int *end, uint32_t *lead_
int
cdi_get_audio_track_pre(cd_img_t *cdi, int track)
{
track_t *trk = &cdi->tracks[track - 1];
const track_t *trk = &cdi->tracks[track - 1];
if ((track < 1) || (track > cdi->tracks_num))
return 0;
@@ -285,7 +285,7 @@ cdi_get_audio_track_pre(cd_img_t *cdi, int track)
int
cdi_get_audio_track_info(cd_img_t *cdi, UNUSED(int end), int track, int *track_num, TMSF *start, uint8_t *attr)
{
track_t *trk = &cdi->tracks[track - 1];
const track_t *trk = &cdi->tracks[track - 1];
int pos = trk->start + 150;
if ((track < 1) || (track > cdi->tracks_num))
@@ -304,7 +304,7 @@ cdi_get_audio_track_info(cd_img_t *cdi, UNUSED(int end), int track, int *track_n
int
cdi_get_audio_track_info_lba(cd_img_t *cdi, UNUSED(int end), int track, int *track_num, uint32_t *start, uint8_t *attr)
{
track_t *trk = &cdi->tracks[track - 1];
const track_t *trk = &cdi->tracks[track - 1];
if ((track < 1) || (track > cdi->tracks_num))
return 0;
@@ -320,8 +320,8 @@ cdi_get_audio_track_info_lba(cd_img_t *cdi, UNUSED(int end), int track, int *tra
int
cdi_get_track(cd_img_t *cdi, uint32_t sector)
{
track_t *cur;
track_t *next;
const track_t *cur;
const track_t *next;
/* There must be at least two tracks - data and lead out. */
if (cdi->tracks_num < 2)
@@ -343,8 +343,8 @@ cdi_get_track(cd_img_t *cdi, uint32_t sector)
int
cdi_get_audio_sub(cd_img_t *cdi, uint32_t sector, uint8_t *attr, uint8_t *track, uint8_t *index, TMSF *rel_pos, TMSF *abs_pos)
{
int cur_track = cdi_get_track(cdi, sector);
track_t *trk;
int cur_track = cdi_get_track(cdi, sector);
const track_t *trk;
if (cur_track < 1)
return 0;
@@ -483,8 +483,8 @@ cdi_read_sector_sub(cd_img_t *cdi, uint8_t *buffer, uint32_t sector)
int
cdi_get_sector_size(cd_img_t *cdi, uint32_t sector)
{
int track = cdi_get_track(cdi, sector) - 1;
track_t *trk;
int track = cdi_get_track(cdi, sector) - 1;
const track_t *trk;
if (track < 0)
return 0;
@@ -496,8 +496,8 @@ cdi_get_sector_size(cd_img_t *cdi, uint32_t sector)
int
cdi_is_mode2(cd_img_t *cdi, uint32_t sector)
{
int track = cdi_get_track(cdi, sector) - 1;
track_t *trk;
int track = cdi_get_track(cdi, sector) - 1;
const track_t *trk;
if (track < 0)
return 0;
@@ -510,8 +510,8 @@ cdi_is_mode2(cd_img_t *cdi, uint32_t sector)
int
cdi_get_mode2_form(cd_img_t *cdi, uint32_t sector)
{
int track = cdi_get_track(cdi, sector) - 1;
track_t *trk;
int track = cdi_get_track(cdi, sector) - 1;
const track_t *trk;
if (track < 0)
return 0;
@@ -652,7 +652,9 @@ cdi_cue_get_buffer(char *str, char **line, int up)
done = 1;
break;
}
/*FALLTHROUGH*/
#ifndef __APPLE__
[[fallthrough]];
#endif
default:
if (up && islower((int) *s))
@@ -787,7 +789,7 @@ cdi_add_track(cd_img_t *cdi, track_t *cur, uint64_t *shift, uint64_t prestart, u
*total_pregap += cur_pregap;
cur->start += *total_pregap;
} else {
temp = prev->file->get_length(prev->file) - ((uint64_t) prev->skip);
temp = prev->file->get_length(prev->file) - (prev->skip);
prev->length = temp / ((uint64_t) prev->sector_size);
if ((temp % prev->sector_size) != 0)
prev->length++;

33
src/cdrom/cdrom_image_viso.c
View File

@@ -370,7 +370,7 @@ viso_fill_fn_rr(uint8_t *data, const viso_entry_t *entry, size_t max_len)
/* Relocate extension if the original name exceeds the maximum length. */
if (!S_ISDIR(entry->stats.st_mode)) { /* do this on files only */
char *ext = strrchr(entry->basename, '.');
const char *ext = strrchr(entry->basename, '.');
if (ext > entry->basename) {
len = strlen(ext);
if (len >= max_len)
@@ -401,7 +401,7 @@ viso_fill_fn_joliet(uint8_t *data, const viso_entry_t *entry, size_t max_len) /*
/* Relocate extension if the original name exceeds the maximum length. */
if (!S_ISDIR(entry->stats.st_mode)) { /* do this on files only */
wchar_t *ext = wcsrchr(utf8dec, L'.');
const wchar_t *ext = wcsrchr(utf8dec, L'.');
if (ext > utf8dec) {
len = wcslen(ext);
if (len > max_len)
@@ -725,8 +725,9 @@ viso_read(void *p, uint8_t *buffer, uint64_t seek, size_t count)
uint64_t
viso_get_length(void *p)
{
track_file_t *tf = (track_file_t *) p;
viso_t *viso = (viso_t *) tf->priv;
track_file_t *tf = (track_file_t *) p;
const viso_t *viso = (viso_t *) tf->priv;
return ((uint64_t) viso->all_sectors) * viso->sector_size;
}
@@ -799,18 +800,18 @@ viso_init(const char *dirname, int *error)
/* Set up directory traversal. */
cdrom_image_viso_log("VISO: Traversing directories:\n");
viso_entry_t *entry;
viso_entry_t *last_entry;
viso_entry_t *dir;
viso_entry_t *last_dir;
viso_entry_t *eltorito_dir = NULL;
viso_entry_t *eltorito_entry = NULL;
struct dirent *readdir_entry;
int len;
int eltorito_others_present = 0;
size_t dir_path_len;
uint64_t eltorito_offset = 0;
uint8_t eltorito_type = 0;
viso_entry_t *entry;
viso_entry_t *last_entry;
viso_entry_t *dir;
viso_entry_t *last_dir;
const viso_entry_t *eltorito_dir = NULL;
const viso_entry_t *eltorito_entry = NULL;
struct dirent *readdir_entry;
int len;
int eltorito_others_present = 0;
size_t dir_path_len;
uint64_t eltorito_offset = 0;
uint8_t eltorito_type = 0;
/* Fill root directory entry. */
dir_path_len = strlen(dirname);

3
src/cdrom/cdrom_mitsumi.c
View File

@@ -324,6 +324,9 @@ mitsumi_cdrom_out(uint16_t port, uint8_t val, void *priv)
break;
case 5:
dev->readmsf = 0;
#ifndef __APPLE__
[[fallthrough]];
#endif
case 4:
case 3:
dev->readmsf |= CD_DCB(val) << ((dev->cmdrd_count - 3) << 3);

20
src/chipset/82c100.c
View File

@@ -109,7 +109,7 @@ ct_82c100_ems_out(uint16_t port, uint8_t val, void *priv)
static uint8_t
ct_82c100_ems_in(uint16_t port, void *priv)
{
ct_82c100_t *dev = (ct_82c100_t *) priv;
const ct_82c100_t *dev = (ct_82c100_t *) priv;
uint8_t ret = 0xff;
ret = dev->ems_page_regs[port >> 14];
@@ -278,15 +278,15 @@ ct_82c100_in(uint16_t port, void *priv)
static uint8_t
mem_read_emsb(uint32_t addr, void *priv)
{
ems_page_t *page = (ems_page_t *) priv;
uint8_t ret = 0xff;
const ems_page_t *page = (ems_page_t *) priv;
uint8_t ret = 0xff;
#ifdef ENABLE_CT_82C100_LOG
uint32_t old_addr = addr;
#endif
addr = addr - page->virt + page->phys;
if (addr < ((uint32_t) mem_size << 10))
if (addr < (mem_size << 10))
ret = ram[addr];
ct_82c100_log("mem_read_emsb(%08X = %08X): %02X\n", old_addr, addr, ret);
@@ -297,7 +297,7 @@ mem_read_emsb(uint32_t addr, void *priv)
static uint16_t
mem_read_emsw(uint32_t addr, void *priv)
{
ems_page_t *page = (ems_page_t *) priv;
const ems_page_t *page = (ems_page_t *) priv;
uint16_t ret = 0xffff;
#ifdef ENABLE_CT_82C100_LOG
uint32_t old_addr = addr;
@@ -305,7 +305,7 @@ mem_read_emsw(uint32_t addr, void *priv)
addr = addr - page->virt + page->phys;
if (addr < ((uint32_t) mem_size << 10))
if (addr < (mem_size << 10))
ret = *(uint16_t *) &ram[addr];
ct_82c100_log("mem_read_emsw(%08X = %08X): %04X\n", old_addr, addr, ret);
@@ -316,14 +316,14 @@ mem_read_emsw(uint32_t addr, void *priv)
static void
mem_write_emsb(uint32_t addr, uint8_t val, void *priv)
{
ems_page_t *page = (ems_page_t *) priv;
const ems_page_t *page = (ems_page_t *) priv;
#ifdef ENABLE_CT_82C100_LOG
uint32_t old_addr = addr;
#endif
addr = addr - page->virt + page->phys;
if (addr < ((uint32_t) mem_size << 10))
if (addr < (mem_size << 10))
ram[addr] = val;
ct_82c100_log("mem_write_emsb(%08X = %08X, %02X)\n", old_addr, addr, val);
@@ -332,14 +332,14 @@ mem_write_emsb(uint32_t addr, uint8_t val, void *priv)
static void
mem_write_emsw(uint32_t addr, uint16_t val, void *priv)
{
ems_page_t *page = (ems_page_t *) priv;
const ems_page_t *page = (ems_page_t *) priv;
#ifdef ENABLE_CT_82C100_LOG
uint32_t old_addr = addr;
#endif
addr = addr - page->virt + page->phys;
if (addr < ((uint32_t) mem_size << 10))
if (addr < (mem_size << 10))
*(uint16_t *) &ram[addr] = val;
ct_82c100_log("mem_write_emsw(%08X = %08X, %04X)\n", old_addr, addr, val);

2
src/chipset/acc2168.c
View File

@@ -168,7 +168,7 @@ acc2168_write(uint16_t addr, uint8_t val, void *priv)
static uint8_t
acc2168_read(uint16_t addr, void *priv)
{
acc2168_t *dev = (acc2168_t *) priv;
const acc2168_t *dev = (acc2168_t *) priv;
return (addr == 0xf3) ? dev->regs[dev->reg_idx] : dev->reg_idx;
}

4
src/chipset/ali1429.c
View File

@@ -280,8 +280,8 @@ ali1429_write(uint16_t addr, uint8_t val, void *priv)
static uint8_t
ali1429_read(uint16_t addr, void *priv)
{
ali1429_t *dev = (ali1429_t *) priv;
uint8_t ret = 0xff;
const ali1429_t *dev = (ali1429_t *) priv;
uint8_t ret = 0xff;
if ((addr == 0x23) && (dev->index >= 0x10) && (dev->index <= 0x4a))
ret = dev->regs[dev->index];

8
src/chipset/ali1435.c
View File

@@ -166,8 +166,8 @@ ali1435_pci_write(int func, int addr, uint8_t val, void *priv)
static uint8_t
ali1435_pci_read(int func, int addr, void *priv)
{
ali1435_t *dev = (ali1435_t *) priv;
uint8_t ret;
const ali1435_t *dev = (ali1435_t *) priv;
uint8_t ret;
ret = 0xff;
@@ -233,8 +233,8 @@ ali1435_write(uint16_t addr, uint8_t val, void *priv)
static uint8_t
ali1435_read(uint16_t addr, void *priv)
{
ali1435_t *dev = (ali1435_t *) priv;
uint8_t ret = 0xff;
const ali1435_t *dev = (ali1435_t *) priv;
uint8_t ret = 0xff;
if ((addr == 0x23) && (dev->index < 0x10))
ret = dev->regs[dev->index];

12
src/chipset/ali1489.c
View File

@@ -408,8 +408,8 @@ ali1489_write(uint16_t addr, uint8_t val, void *priv)
static uint8_t
ali1489_read(uint16_t addr, void *priv)
{
uint8_t ret = 0xff;
ali1489_t *dev = (ali1489_t *) priv;
uint8_t ret = 0xff;
const ali1489_t *dev = (ali1489_t *) priv;
switch (addr) {
case 0x23:
@@ -456,8 +456,8 @@ ali1489_pci_write(UNUSED(int func), int addr, uint8_t val, void *priv)
static uint8_t
ali1489_pci_read(UNUSED(int func), int addr, void *priv)
{
ali1489_t *dev = (ali1489_t *) priv;
uint8_t ret = 0xff;
const ali1489_t *dev = (ali1489_t *) priv;
uint8_t ret = 0xff;
ret = dev->pci_conf[addr];
ali1489_log("M1489-PCI: dev->pci_conf[%02x] (%02x)\n", addr, ret);
@@ -560,8 +560,8 @@ ali1489_ide_write(uint16_t addr, uint8_t val, void *priv)
static uint8_t
ali1489_ide_read(uint16_t addr, void *priv)
{
ali1489_t *dev = (ali1489_t *) priv;
uint8_t ret = 0xff;
const ali1489_t *dev = (ali1489_t *) priv;
uint8_t ret = 0xff;
switch (addr) {
case 0xf4:

4
src/chipset/ali1531.c
View File

@@ -303,8 +303,8 @@ ali1531_write(UNUSED(int func), int addr, uint8_t val, void *priv)
static uint8_t
ali1531_read(UNUSED(int func), int addr, void *priv)
{
ali1531_t *dev = (ali1531_t *) priv;
uint8_t ret = 0xff;
const ali1531_t *dev = (ali1531_t *) priv;
uint8_t ret = 0xff;
ret = dev->pci_conf[addr];

4
src/chipset/ali1541.c
View File

@@ -560,8 +560,8 @@ ali1541_write(UNUSED(int func), int addr, uint8_t val, void *priv)
static uint8_t
ali1541_read(UNUSED(int func), int addr, void *priv)
{
ali1541_t *dev = (ali1541_t *) priv;
uint8_t ret = 0xff;
const ali1541_t *dev = (ali1541_t *) priv;
uint8_t ret = 0xff;
ret = dev->pci_conf[addr];

6
src/chipset/ali1543.c
View File

@@ -895,7 +895,7 @@ ali5229_write(int func, int addr, uint8_t val, void *priv)
static uint8_t
ali5229_read(int func, int addr, void *priv)
{
ali1543_t *dev = (ali1543_t *) priv;
const ali1543_t *dev = (ali1543_t *) priv;
uint8_t ret = 0xff;
if (dev->ide_dev_enable && (func == 0)) {
@@ -983,7 +983,7 @@ ali5237_write(int func, int addr, uint8_t val, void *priv)
static uint8_t
ali5237_read(int func, int addr, void *priv)
{
ali1543_t *dev = (ali1543_t *) priv;
const ali1543_t *dev = (ali1543_t *) priv;
uint8_t ret = 0xff;
if (dev->usb_dev_enable && (func == 0))
@@ -1474,7 +1474,7 @@ ali7101_read(int func, int addr, void *priv)
static void
ali5237_usb_update_interrupt(usb_t* usb, void *priv)
{
ali1543_t *dev = (ali1543_t *) priv;
const ali1543_t *dev = (ali1543_t *) priv;
if (usb->irq_level)
pci_set_mirq(4, !!(dev->pci_conf[0x74] & 0x10));

12
src/chipset/ali1621.c
View File

@@ -108,7 +108,9 @@ ali1621_smram_recalc(uint8_t val, ali1621_t *dev)
switch (val & 0x30) {
case 0x10: /* Open. */
access_normal = ACCESS_SMRAM_RX;
/* FALLTHROUGH */
#ifndef __APPLE__
[[fallthrough]];
#endif
case 0x30: /* Protect. */
access_smm |= ACCESS_SMRAM_R;
break;
@@ -121,7 +123,9 @@ ali1621_smram_recalc(uint8_t val, ali1621_t *dev)
switch (val & 0x30) {
case 0x10: /* Open. */
access_normal |= ACCESS_SMRAM_W;
/* FALLTHROUGH */
#ifndef __APPLE__
[[fallthrough]];
#endif
case 0x30: /* Protect. */
access_smm |= ACCESS_SMRAM_W;
break;
@@ -579,8 +583,8 @@ ali1621_write(UNUSED(int func), int addr, uint8_t val, void *priv)
static uint8_t
ali1621_read(UNUSED(int func), int addr, void *priv)
{
ali1621_t *dev = (ali1621_t *) priv;
uint8_t ret = 0xff;
const ali1621_t *dev = (ali1621_t *) priv;
uint8_t ret = 0xff;
ret = dev->pci_conf[addr];

6
src/chipset/ali6117.c
View File

@@ -233,7 +233,9 @@ ali6117_reg_write(uint16_t addr, uint8_t val, void *priv)
case 0x12:
val &= 0xf7;
/* FALL-THROUGH */
#ifndef __APPLE__
[[fallthrough]];
#endif
case 0x14:
case 0x15:
@@ -388,7 +390,7 @@ ali6117_reg_write(uint16_t addr, uint8_t val, void *priv)
static uint8_t
ali6117_reg_read(uint16_t addr, void *priv)
{
ali6117_t *dev = (ali6117_t *) priv;
const ali6117_t *dev = (ali6117_t *) priv;
uint8_t ret;
if (addr == 0x22)

2
src/chipset/cs4031.c
View File

@@ -148,7 +148,7 @@ cs4031_write(uint16_t addr, uint8_t val, void *priv)
static uint8_t
cs4031_read(uint16_t addr, void *priv)
{
cs4031_t *dev = (cs4031_t *) priv;
const cs4031_t *dev = (cs4031_t *) priv;
return (addr == 0x23) ? dev->regs[dev->index] : 0xff;
}

4
src/chipset/cs8230.c
View File

@@ -81,8 +81,8 @@ rethink_shadow_mappings(cs8230_t *cs8230)
static uint8_t
cs8230_read(uint16_t port, void *priv)
{
cs8230_t *cs8230 = (cs8230_t *) priv;
uint8_t ret = 0xff;
const cs8230_t *cs8230 = (cs8230_t *) priv;
uint8_t ret = 0xff;
if (port & 1) {
switch (cs8230->idx) {

2
src/chipset/et6000.c
View File

@@ -121,7 +121,7 @@ et6000_write(uint16_t addr, uint8_t val, void *priv)
static uint8_t
et6000_read(uint16_t addr, void *priv)
{
et6000_t *dev = (et6000_t *) priv;
const et6000_t *dev = (et6000_t *) priv;
return ((addr == 0x23) && (INDEX >= 0) && (INDEX <= 5)) ? dev->regs[INDEX] : 0xff;
}

6
src/chipset/gc100.c
View File

@@ -145,9 +145,9 @@ gc100_write(uint16_t port, uint8_t val, void *priv)
static uint8_t
gc100_read(uint16_t port, void *priv)
{
gc100_t *dev = (gc100_t *) priv;
uint8_t ret = 0xff;
uint16_t addr = port & 0xf;
const gc100_t *dev = (gc100_t *) priv;
uint8_t ret = 0xff;
uint16_t addr = port & 0xf;
ret = dev->reg[addr];

18
src/chipset/headland.c
View File

@@ -165,7 +165,7 @@ get_addr(headland_t *dev, uint32_t addr, headland_mr_t *mr)
static void
hl_ems_disable(headland_t *dev, uint8_t mar, uint32_t base_addr, uint8_t indx)
{
if (base_addr < ((uint32_t) mem_size << 10))
if (base_addr < (mem_size << 10))
mem_mapping_set_exec(&dev->ems_mapping[mar & 0x3f], ram + base_addr);
else
mem_mapping_set_exec(&dev->ems_mapping[mar & 0x3f], NULL);
@@ -197,7 +197,7 @@ hl_ems_update(headland_t *dev, uint8_t mar)
dev->ems_mr[mar & 0x3f].virt_base = virt_addr;
if (indx < 24)
mem_mapping_disable(&dev->upper_mapping[indx]);
if (virt_addr < ((uint32_t) mem_size << 10))
if (virt_addr < (mem_size << 10))
mem_mapping_set_exec(&dev->ems_mapping[mar & 0x3f], ram + virt_addr);
else
mem_mapping_set_exec(&dev->ems_mapping[mar & 0x3f], NULL);
@@ -244,7 +244,7 @@ memmap_state_update(headland_t *dev)
for (uint8_t i = 0; i < 24; i++) {
addr = get_addr(dev, 0x40000 + (i << 14), NULL);
mem_mapping_set_exec(&dev->upper_mapping[i], addr < ((uint32_t) mem_size << 10) ? ram + addr : NULL);
mem_mapping_set_exec(&dev->upper_mapping[i], addr < (mem_size << 10) ? ram + addr : NULL);
}
memmap_state_default(dev, ht_romcs);
@@ -513,7 +513,7 @@ mem_read_b(uint32_t addr, void *priv)
uint8_t ret = 0xff;
addr = get_addr(dev, addr, mr);
if (addr < ((uint32_t) mem_size << 10))
if (addr < (mem_size << 10))
ret = ram[addr];
return ret;
@@ -527,7 +527,7 @@ mem_read_w(uint32_t addr, void *priv)
uint16_t ret = 0xffff;
addr = get_addr(dev, addr, mr);
if (addr < ((uint32_t) mem_size << 10))
if (addr < (mem_size << 10))
ret = *(uint16_t *) &ram[addr];
return ret;
@@ -541,7 +541,7 @@ mem_read_l(uint32_t addr, void *priv)
uint32_t ret = 0xffffffff;
addr = get_addr(dev, addr, mr);
if (addr < ((uint32_t) mem_size << 10))
if (addr < (mem_size << 10))
ret = *(uint32_t *) &ram[addr];
return ret;
@@ -554,7 +554,7 @@ mem_write_b(uint32_t addr, uint8_t val, void *priv)
headland_t *dev = mr->headland;
addr = get_addr(dev, addr, mr);
if (addr < ((uint32_t) mem_size << 10))
if (addr < (mem_size << 10))
ram[addr] = val;
}
@@ -565,7 +565,7 @@ mem_write_w(uint32_t addr, uint16_t val, void *priv)
headland_t *dev = mr->headland;
addr = get_addr(dev, addr, mr);
if (addr < ((uint32_t) mem_size << 10))
if (addr < (mem_size << 10))
*(uint16_t *) &ram[addr] = val;
}
@@ -576,7 +576,7 @@ mem_write_l(uint32_t addr, uint32_t val, void *priv)
headland_t *dev = mr->headland;
addr = get_addr(dev, addr, mr);
if (addr < ((uint32_t) mem_size << 10))
if (addr < (mem_size << 10))
*(uint32_t *) &ram[addr] = val;
}

4
src/chipset/ims8848.c
View File

@@ -327,8 +327,8 @@ ims8849_pci_write(int func, int addr, uint8_t val, void *priv)
static uint8_t
ims8849_pci_read(int func, int addr, void *priv)
{
ims8848_t *dev = (ims8848_t *) priv;
uint8_t ret = 0xff;
const ims8848_t *dev = (ims8848_t *) priv;
uint8_t ret = 0xff;
if (func == 0)
ret = dev->pci_conf[addr];

15
src/chipset/intel_420ex.c
View File

@@ -118,7 +118,7 @@ i420ex_smram_handler_phase0(void)
static void
i420ex_smram_handler_phase1(i420ex_t *dev)
{
uint8_t *regs = (uint8_t *) dev->regs;
const uint8_t *regs = (uint8_t *) dev->regs;
uint32_t host_base = 0x000a0000;
uint32_t ram_base = 0x000a0000;
@@ -165,15 +165,14 @@ i420ex_smram_handler_phase1(i420ex_t *dev)
static void
i420ex_drb_recalc(i420ex_t *dev)
{
int i;
uint32_t boundary;
for (i = 4; i >= 0; i--)
for (uint8_t i = 4; i >= 0; i--)
row_disable(i);
for (i = 0; i <= 4; i++) {
boundary = ((uint32_t) dev->regs[0x60 + i]) & 0xff;
row_set_boundary(i, boundary);
for (uint8_t i = 0; i <= 4; i++) {
boundary = ((uint32_t) dev->regs[0x60 + i]) & 0xff;
row_set_boundary(i, boundary);
}
flushmmucache();
@@ -398,8 +397,8 @@ i420ex_write(int func, int addr, uint8_t val, void *priv)
static uint8_t
i420ex_read(int func, int addr, void *priv)
{
i420ex_t *dev = (i420ex_t *) priv;
uint8_t ret;
const i420ex_t *dev = (i420ex_t *) priv;
uint8_t ret;
ret = 0xff;

20
src/chipset/intel_4x0.c
View File

@@ -118,10 +118,10 @@ static void
i4x0_smram_handler_phase1(i4x0_t *dev)
{
uint8_t *regs = (uint8_t *) dev->regs;
uint32_t tom = (mem_size << 10);
uint8_t *reg = (dev->type >= INTEL_430LX) ? &(regs[0x72]) : &(regs[0x57]);
uint8_t *ext_reg = (dev->type >= INTEL_440BX) ? &(regs[0x73]) : &(regs[0x71]);
const uint8_t *regs = (uint8_t *) dev->regs;
uint32_t tom = (mem_size << 10);
const uint8_t *reg = (dev->type >= INTEL_430LX) ? &(regs[0x72]) : &(regs[0x57]);
const uint8_t *ext_reg = (dev->type >= INTEL_440BX) ? &(regs[0x73]) : &(regs[0x71]);
uint32_t s;
uint32_t base[2] = { 0x000a0000, 0x00000000 };
@@ -228,7 +228,7 @@ i4x0_mask_bar(uint8_t *regs, void *agpgart)
static uint8_t
pm2_cntrl_read(UNUSED(uint16_t addr), void *priv)
{
i4x0_t *dev = (i4x0_t *) priv;
const i4x0_t *dev = (i4x0_t *) priv;
return dev->pm2_cntrl & 0x01;
}
@@ -1068,6 +1068,8 @@ i4x0_write(int func, int addr, uint8_t val, void *priv)
case INTEL_440ZX:
case INTEL_440GX:
regs[addr] = val;
break;
default:
break;
}
@@ -1077,6 +1079,8 @@ i4x0_write(int func, int addr, uint8_t val, void *priv)
case INTEL_440BX:
case INTEL_440ZX:
regs[0x77] = val & 0x03;
break;
default:
break;
}
@@ -1505,9 +1509,9 @@ i4x0_write(int func, int addr, uint8_t val, void *priv)
static uint8_t
i4x0_read(int func, int addr, void *priv)
{
i4x0_t *dev = (i4x0_t *) priv;
uint8_t ret = 0xff;
uint8_t *regs = (uint8_t *) dev->regs;
i4x0_t *dev = (i4x0_t *) priv;
uint8_t ret = 0xff;
const uint8_t *regs = (uint8_t *) dev->regs;
if (func == 0) {
ret = regs[addr];

2
src/chipset/intel_82335.c
View File

@@ -153,7 +153,7 @@ intel_82335_write(uint16_t addr, uint16_t val, void *priv)
static uint16_t
intel_82335_read(uint16_t addr, void *priv)
{
intel_82335_t *dev = (intel_82335_t *) priv;
const intel_82335_t *dev = (intel_82335_t *) priv;
intel_82335_log("Register %02x: Read %04x\n", addr, dev->regs[addr]);

12
src/chipset/intel_i450kx.c
View File

@@ -90,9 +90,9 @@ i450kx_map(i450kx_t *dev, int bus, uint32_t addr, uint32_t size, int state)
static void
i450kx_smram_recalc(i450kx_t *dev, int bus)
{
uint8_t *regs = bus ? dev->pb_pci_conf : dev->mc_pci_conf;
uint32_t addr;
uint32_t size;
const uint8_t *regs = bus ? dev->pb_pci_conf : dev->mc_pci_conf;
uint32_t addr;
uint32_t size;
smram_disable(dev->smram[bus]);
@@ -112,7 +112,7 @@ i450kx_smram_recalc(i450kx_t *dev, int bus)
static void
i450kx_vid_buf_recalc(i450kx_t *dev, int bus)
{
uint8_t *regs = bus ? dev->pb_pci_conf : dev->mc_pci_conf;
const uint8_t *regs = bus ? dev->pb_pci_conf : dev->mc_pci_conf;
#if 0
// int state = (regs[0x58] & 0x02) ? (MEM_READ_EXTANY | MEM_WRITE_EXTANY) : (MEM_READ_DISABLED | MEM_WRITE_DISABLED);
@@ -374,7 +374,7 @@ pb_write(int func, int addr, uint8_t val, void *priv)
static uint8_t
pb_read(int func, int addr, void *priv)
{
i450kx_t *dev = (i450kx_t *) priv;
const i450kx_t *dev = (i450kx_t *) priv;
uint8_t ret = 0xff;
if (func == 0)
@@ -601,7 +601,7 @@ mc_write(int func, int addr, uint8_t val, void *priv)
static uint8_t
mc_read(int func, int addr, void *priv)
{
i450kx_t *dev = (i450kx_t *) priv;
const i450kx_t *dev = (i450kx_t *) priv;
uint8_t ret = 0xff;
if (func == 0)

24
src/chipset/intel_piix.c
View File

@@ -289,7 +289,7 @@ piix_trap_io(UNUSED(int size), UNUSED(uint16_t addr), UNUSED(uint8_t write), UNU
static void
piix_trap_io_ide(int size, uint16_t addr, uint8_t write, uint8_t val, void *priv)
{
piix_io_trap_t *trap = (piix_io_trap_t *) priv;
const piix_io_trap_t *trap = (piix_io_trap_t *) priv;
/* IDE traps are per drive, not per channel. */
if (ide_drives[trap->dev_id]->selected)
@@ -327,10 +327,10 @@ piix_trap_update_devctl(piix_t *dev, uint8_t trap_id, uint8_t dev_id,
static void
piix_trap_update(void *priv)
{
piix_t *dev = (piix_t *) priv;
uint8_t trap_id = 0;
uint8_t *fregs = dev->regs[3];
uint16_t temp;
piix_t *dev = (piix_t *) priv;
uint8_t trap_id = 0;
const uint8_t *fregs = dev->regs[3];
uint16_t temp;
piix_trap_update_devctl(dev, trap_id++, 0, 0x00000002, 1, 0x1f0, 8);
piix_trap_update_devctl(dev, trap_id++, 0, 0x00000002, 1, 0x3f6, 1);
@@ -1166,9 +1166,9 @@ piix_write(int func, int addr, uint8_t val, void *priv)
static uint8_t
piix_read(int func, int addr, void *priv)
{
piix_t *dev = (piix_t *) priv;
uint8_t ret = 0xff;
uint8_t *fregs;
piix_t *dev = (piix_t *) priv;
uint8_t ret = 0xff;
const uint8_t *fregs;
if ((dev->type == 3) && (func == 2) && (dev->max_func == 1) && (addr >= 0x40))
ret = 0x00;
@@ -1202,8 +1202,8 @@ board_write(uint16_t port, uint8_t val, void *priv)
static uint8_t
board_read(uint16_t port, void *priv)
{
piix_t *dev = (piix_t *) priv;
uint8_t ret = 0x64;
const piix_t *dev = (piix_t *) priv;
uint8_t ret = 0x64;
if (port == 0x0078)
ret = dev->board_config[0];
@@ -1446,7 +1446,7 @@ piix_fast_off_count(void *priv)
static void
piix_usb_update_interrupt(usb_t* usb, void *priv)
{
piix_t *dev = (piix_t *) priv;
const piix_t *dev = (piix_t *) priv;
if (usb->irq_level)
pci_set_irq(dev->pci_slot, PCI_INTD);
@@ -1457,7 +1457,7 @@ piix_usb_update_interrupt(usb_t* usb, void *priv)
static void
piix_reset(void *priv)
{
piix_t *dev = (piix_t *) priv;
const piix_t *dev = (piix_t *) priv;
if (dev->type > 3) {
piix_write(3, 0x04, 0x00, priv);

6
src/chipset/intel_sio.c
View File

@@ -324,8 +324,8 @@ sio_write(int func, int addr, uint8_t val, void *priv)
static uint8_t
sio_read(int func, int addr, void *priv)
{
sio_t *dev = (sio_t *) priv;
uint8_t ret;
const sio_t *dev = (sio_t *) priv;
uint8_t ret;
ret = 0xff;
@@ -452,7 +452,7 @@ sio_fast_off_count(void *priv)
static void
sio_reset(void *priv)
{
sio_t *dev = (sio_t *) priv;
const sio_t *dev = (sio_t *) priv;
/* Disable the PIC mouse latch. */
sio_write(0, 0x4d, 0x40, priv);

10
src/chipset/neat.c
View File

@@ -349,9 +349,9 @@ ems_write(uint16_t port, uint8_t val, void *priv)
static uint8_t
ems_read(uint16_t port, void *priv)
{
neat_t *dev = (neat_t *) priv;
uint8_t ret = 0xff;
int vpage;
const neat_t *dev = (neat_t *) priv;
uint8_t ret = 0xff;
int vpage;
/* Get the viewport page number. */
vpage = (port / EMS_PGSIZE);
@@ -637,8 +637,8 @@ neat_write(uint16_t port, uint8_t val, void *priv)
static uint8_t
neat_read(uint16_t port, void *priv)
{
neat_t *dev = (neat_t *) priv;
uint8_t ret = 0xff;
const neat_t *dev = (neat_t *) priv;
uint8_t ret = 0xff;
switch (port) {
case 0x22:

20
src/chipset/opti283.c
View File

@@ -66,7 +66,7 @@ typedef struct opti283_t {
static uint8_t
opti283_read_remapped_ram(uint32_t addr, void *priv)
{
mem_remapping_t *dev = (mem_remapping_t *) priv;
const mem_remapping_t *dev = (mem_remapping_t *) priv;
return mem_read_ram((addr - dev->virt) + dev->phys, priv);
}
@@ -74,7 +74,7 @@ opti283_read_remapped_ram(uint32_t addr, void *priv)
static uint16_t
opti283_read_remapped_ramw(uint32_t addr, void *priv)
{
mem_remapping_t *dev = (mem_remapping_t *) priv;
const mem_remapping_t *dev = (mem_remapping_t *) priv;
return mem_read_ramw((addr - dev->virt) + dev->phys, priv);
}
@@ -82,7 +82,7 @@ opti283_read_remapped_ramw(uint32_t addr, void *priv)
static uint32_t
opti283_read_remapped_raml(uint32_t addr, void *priv)
{
mem_remapping_t *dev = (mem_remapping_t *) priv;
const mem_remapping_t *dev = (mem_remapping_t *) priv;
return mem_read_raml((addr - dev->virt) + dev->phys, priv);
}
@@ -90,7 +90,7 @@ opti283_read_remapped_raml(uint32_t addr, void *priv)
static void
opti283_write_remapped_ram(uint32_t addr, uint8_t val, void *priv)
{
mem_remapping_t *dev = (mem_remapping_t *) priv;
const mem_remapping_t *dev = (mem_remapping_t *) priv;
mem_write_ram((addr - dev->virt) + dev->phys, val, priv);
}
@@ -98,7 +98,7 @@ opti283_write_remapped_ram(uint32_t addr, uint8_t val, void *priv)
static void
opti283_write_remapped_ramw(uint32_t addr, uint16_t val, void *priv)
{
mem_remapping_t *dev = (mem_remapping_t *) priv;
const mem_remapping_t *dev = (mem_remapping_t *) priv;
mem_write_ramw((addr - dev->virt) + dev->phys, val, priv);
}
@@ -106,7 +106,7 @@ opti283_write_remapped_ramw(uint32_t addr, uint16_t val, void *priv)
static void
opti283_write_remapped_raml(uint32_t addr, uint32_t val, void *priv)
{
mem_remapping_t *dev = (mem_remapping_t *) priv;
const mem_remapping_t *dev = (mem_remapping_t *) priv;
mem_write_raml((addr - dev->virt) + dev->phys, val, priv);
}
@@ -228,7 +228,9 @@ opti283_write(uint16_t addr, uint8_t val, void *priv)
case 0x14:
reset_on_hlt = !!(val & 0x40);
/* FALLTHROUGH */
#ifndef __APPLE__
[[fallthrough]];
#endif
case 0x11:
case 0x12:
case 0x13:
@@ -249,8 +251,8 @@ opti283_write(uint16_t addr, uint8_t val, void *priv)
static uint8_t
opti283_read(uint16_t addr, void *priv)
{
opti283_t *dev = (opti283_t *) priv;
uint8_t ret = 0xff;
const opti283_t *dev = (opti283_t *) priv;
uint8_t ret = 0xff;
if (addr == 0x24)
ret = dev->regs[dev->index];

2
src/chipset/opti291.c
View File

@@ -122,7 +122,7 @@ opti291_write(uint16_t addr, uint8_t val, void *priv)
static uint8_t
opti291_read(uint16_t addr, void *priv)
{
opti291_t *dev = (opti291_t *) priv;
const opti291_t *dev = (opti291_t *) priv;
return (addr == 0x24) ? dev->regs[dev->index] : 0xff;
}

4
src/chipset/opti391.c
View File

@@ -178,8 +178,8 @@ opti391_write(uint16_t addr, uint8_t val, void *priv)
static uint8_t
opti391_read(uint16_t addr, void *priv)
{
opti391_t *dev = (opti391_t *) priv;
uint8_t ret = 0xff;
const opti391_t *dev = (opti391_t *) priv;
uint8_t ret = 0xff;
if (addr == 0x24)
ret = dev->regs[dev->index];

4
src/chipset/opti495.c
View File

@@ -157,8 +157,8 @@ opti495_write(uint16_t addr, uint8_t val, void *priv)
static uint8_t
opti495_read(uint16_t addr, void *priv)
{
uint8_t ret = 0xff;
opti495_t *dev = (opti495_t *) priv;
uint8_t ret = 0xff;
const opti495_t *dev = (opti495_t *) priv;
switch (addr) {
case 0x22:

2
src/chipset/opti5x7.c
View File

@@ -156,7 +156,7 @@ opti5x7_write(uint16_t addr, uint8_t val, void *priv)
static uint8_t
opti5x7_read(uint16_t addr, void *priv)
{
opti5x7_t *dev = (opti5x7_t *) priv;
const opti5x7_t *dev = (opti5x7_t *) priv;
return (addr == 0x24) ? dev->regs[dev->idx] : 0xff;
}

4
src/chipset/opti822.c
View File

@@ -336,8 +336,8 @@ opti822_pci_write(int func, int addr, uint8_t val, void *priv)
static uint8_t
opti822_pci_read(int func, int addr, void *priv)
{
opti822_t *dev = (opti822_t *) priv;
uint8_t ret;
const opti822_t *dev = (opti822_t *) priv;
uint8_t ret;
ret = 0xff;

4
src/chipset/opti895.c
View File

@@ -204,8 +204,8 @@ opti895_write(uint16_t addr, uint8_t val, void *priv)
static uint8_t
opti895_read(uint16_t addr, void *priv)
{
uint8_t ret = 0xff;
opti895_t *dev = (opti895_t *) priv;
uint8_t ret = 0xff;
const opti895_t *dev = (opti895_t *) priv;
switch (addr) {
case 0x23:

84
src/chipset/scamp.c
View File

@@ -152,12 +152,12 @@ static const struct {
static uint8_t
ram_mirrored_256k_in_4mi_read(uint32_t addr, void *priv)
{
ram_struct_t *rs = (ram_struct_t *) priv;
scamp_t *dev = rs->parent;
int bank = rs->bank;
int byte;
int row;
int column;
const ram_struct_t *rs = (ram_struct_t *) priv;
const scamp_t *dev = rs->parent;
int bank = rs->bank;
int byte;
int row;
int column;
addr -= dev->ram_virt_base[bank];
byte = addr & 1;
@@ -183,12 +183,12 @@ ram_mirrored_256k_in_4mi_read(uint32_t addr, void *priv)
static void
ram_mirrored_256k_in_4mi_write(uint32_t addr, uint8_t val, void *priv)
{
ram_struct_t *rs = (ram_struct_t *) priv;
scamp_t *dev = rs->parent;
int bank = rs->bank;
int byte;
int row;
int column;
const ram_struct_t *rs = (ram_struct_t *) priv;
const scamp_t *dev = rs->parent;
int bank = rs->bank;
int byte;
int row;
int column;
addr -= dev->ram_virt_base[bank];
byte = addr & 1;
@@ -216,12 +216,12 @@ ram_mirrored_256k_in_4mi_write(uint32_t addr, uint8_t val, void *priv)
static uint8_t
ram_mirrored_interleaved_read(uint32_t addr, void *priv)
{
ram_struct_t *rs = (ram_struct_t *) priv;
scamp_t *dev = rs->parent;
int bank = rs->bank;
int byte;
int row;
int column;
const ram_struct_t *rs = (ram_struct_t *) priv;
const scamp_t *dev = rs->parent;
int bank = rs->bank;
int byte;
int row;
int column;
addr -= dev->ram_virt_base[bank];
byte = addr & 1;
@@ -247,12 +247,12 @@ ram_mirrored_interleaved_read(uint32_t addr, void *priv)
static void
ram_mirrored_interleaved_write(uint32_t addr, uint8_t val, void *priv)
{
ram_struct_t *rs = (ram_struct_t *) priv;
scamp_t *dev = rs->parent;
int bank = rs->bank;
int byte;
int row;
int column;
const ram_struct_t *rs = (ram_struct_t *) priv;
const scamp_t *dev = rs->parent;
int bank = rs->bank;
int byte;
int row;
int column;
addr -= dev->ram_virt_base[bank];
byte = addr & 1;
@@ -278,12 +278,12 @@ ram_mirrored_interleaved_write(uint32_t addr, uint8_t val, void *priv)
static uint8_t
ram_mirrored_read(uint32_t addr, void *priv)
{
ram_struct_t *rs = (ram_struct_t *) priv;
scamp_t *dev = rs->parent;
int bank = rs->bank;
int byte;
int row;
int column;
const ram_struct_t *rs = (ram_struct_t *) priv;
const scamp_t *dev = rs->parent;
int bank = rs->bank;
int byte;
int row;
int column;
addr -= dev->ram_virt_base[bank];
byte = addr & 1;
@@ -297,12 +297,12 @@ ram_mirrored_read(uint32_t addr, void *priv)
static void
ram_mirrored_write(uint32_t addr, uint8_t val, void *priv)
{
ram_struct_t *rs = (ram_struct_t *) priv;
scamp_t *dev = rs->parent;
int bank = rs->bank;
int byte;
int row;
int column;
const ram_struct_t *rs = (ram_struct_t *) priv;
const scamp_t *dev = rs->parent;
int bank = rs->bank;
int byte;
int row;
int column;
addr -= dev->ram_virt_base[bank];
byte = addr & 1;
@@ -574,9 +574,9 @@ recalc_sltptr(scamp_t *dev)
static uint8_t
scamp_ems_read(uint32_t addr, void *priv)
{
ems_struct_t *ems = (ems_struct_t *) priv;
scamp_t *dev = ems->parent;
int segment = ems->segment;
const ems_struct_t *ems = (ems_struct_t *) priv;
const scamp_t *dev = ems->parent;
int segment = ems->segment;
addr = (addr & 0x3fff) | dev->mappings[segment];
return ram[addr];
@@ -585,9 +585,9 @@ scamp_ems_read(uint32_t addr, void *priv)
static void
scamp_ems_write(uint32_t addr, uint8_t val, void *priv)
{
ems_struct_t *ems = (ems_struct_t *) priv;
scamp_t *dev = ems->parent;
int segment = ems->segment;
const ems_struct_t *ems = (ems_struct_t *) priv;
const scamp_t *dev = ems->parent;
int segment = ems->segment;
addr = (addr & 0x3fff) | dev->mappings[segment];
ram[addr] = val;

6
src/chipset/scat.c
View File

@@ -1204,9 +1204,9 @@ scat_out(uint16_t port, uint8_t val, void *priv)
static uint8_t
scat_in(uint16_t port, void *priv)
{
scat_t *dev = (scat_t *) priv;
uint8_t ret = 0xff;
uint8_t indx;
const scat_t *dev = (scat_t *) priv;
uint8_t ret = 0xff;
uint8_t indx;
switch (port) {
case 0x23:

7
src/chipset/sis_5511.c
View File

@@ -348,7 +348,8 @@ sis_5511_write(UNUSED(int func), int addr, uint8_t val, void *priv)
static uint8_t
sis_5511_read(UNUSED(int func), int addr, void *priv)
{
sis_5511_t *dev = (sis_5511_t *) priv;
const sis_5511_t *dev = (sis_5511_t *) priv;
sis_5511_log("SiS 5511: dev->pci_conf[%02x] (%02x) POST %02x\n", addr, dev->pci_conf[addr], inb(0x80));
return dev->pci_conf[addr];
}
@@ -554,7 +555,7 @@ sis_5513_write(int func, int addr, uint8_t val, void *priv)
static uint8_t
sis_5513_read(int func, int addr, void *priv)
{
sis_5511_t *dev = (sis_5511_t *) priv;
const sis_5511_t *dev = (sis_5511_t *) priv;
sis_5511_log("SiS 5513: dev->pci_conf[%02x][%02x] = %02x POST %02x\n", func, addr, dev->pci_conf_sb[func][addr], inb(0x80));
if ((func >= 0) && (func <= 1))
@@ -624,7 +625,7 @@ sis_5513_isa_write(uint16_t addr, uint8_t val, void *priv)
static uint8_t
sis_5513_isa_read(uint16_t addr, void *priv)
{
sis_5511_t *dev = (sis_5511_t *) priv;
const sis_5511_t *dev = (sis_5511_t *) priv;
if (addr == 0x23) {
sis_5511_log("SiS 5513-ISA: dev->regs[%02x] (%02x) POST: %02x\n", dev->index + 0x50, dev->regs[dev->index], inb(0x80));

8
src/chipset/sis_5571.c
View File

@@ -340,7 +340,8 @@ memory_pci_bridge_write(UNUSED(int func), int addr, uint8_t val, void *priv)
static uint8_t
memory_pci_bridge_read(UNUSED(int func), int addr, void *priv)
{
sis_5571_t *dev = (sis_5571_t *) priv;
const sis_5571_t *dev = (sis_5571_t *) priv;
sis_5571_log("SiS5571: dev->pci_conf[%02x] (%02x)\n", addr, dev->pci_conf[addr]);
return dev->pci_conf[addr];
}
@@ -638,6 +639,7 @@ pci_isa_bridge_write(int func, int addr, uint8_t val, void *priv)
break;
}
sis_5571_log("SiS5571-USB: dev->pci_conf[%02x] = %02x\n", addr, val);
break;
default:
break;
@@ -647,7 +649,7 @@ pci_isa_bridge_write(int func, int addr, uint8_t val, void *priv)
static uint8_t
pci_isa_bridge_read(int func, int addr, void *priv)
{
sis_5571_t *dev = (sis_5571_t *) priv;
const sis_5571_t *dev = (sis_5571_t *) priv;
switch (func) {
case 0:
@@ -668,7 +670,7 @@ pci_isa_bridge_read(int func, int addr, void *priv)
static void
sis_5571_usb_update_interrupt(usb_t* usb, void* priv)
{
sis_5571_t *dev = (sis_5571_t *) priv;
const sis_5571_t *dev = (sis_5571_t *) priv;
if (dev->pci_conf_sb[0][0x68] & 0x80) {
/* TODO: Is the normal PCI interrupt inhibited when USB IRQ remapping is enabled? */

8
src/chipset/sis_85c496.c
View File

@@ -115,8 +115,8 @@ sis_85c497_isa_write(uint16_t port, uint8_t val, void *priv)
static uint8_t
sis_85c497_isa_read(uint16_t port, void *priv)
{
sis_85c496_t *dev = (sis_85c496_t *) priv;
uint8_t ret = 0xff;
const sis_85c496_t *dev = (sis_85c496_t *) priv;
uint8_t ret = 0xff;
if (port == 0x23)
ret = dev->regs[dev->cur_reg];
@@ -505,8 +505,8 @@ sis_85c49x_pci_write(UNUSED(int func), int addr, uint8_t val, void *priv)
static uint8_t
sis_85c49x_pci_read(UNUSED(int func), int addr, void *priv)
{
sis_85c496_t *dev = (sis_85c496_t *) priv;
uint8_t ret = dev->pci_conf[addr];
const sis_85c496_t *dev = (sis_85c496_t *) priv;
uint8_t ret = dev->pci_conf[addr];
switch (addr) {
case 0xa0:

12
src/chipset/sis_85c50x.c
View File

@@ -228,8 +228,8 @@ sis_85c50x_write(int func, int addr, uint8_t val, void *priv)
static uint8_t
sis_85c50x_read(int func, int addr, void *priv)
{
sis_85c50x_t *dev = (sis_85c50x_t *) priv;
uint8_t ret = 0xff;
const sis_85c50x_t *dev = (sis_85c50x_t *) priv;
uint8_t ret = 0xff;
if (func == 0x00)
ret = dev->pci_conf[addr];
@@ -283,8 +283,8 @@ sis_85c50x_sb_write(int func, int addr, uint8_t val, void *priv)
static uint8_t
sis_85c50x_sb_read(int func, int addr, void *priv)
{
sis_85c50x_t *dev = (sis_85c50x_t *) priv;
uint8_t ret = 0xff;
const sis_85c50x_t *dev = (sis_85c50x_t *) priv;
uint8_t ret = 0xff;
if (func == 0x00)
ret = dev->pci_conf_sb[addr];
@@ -338,8 +338,8 @@ sis_85c50x_isa_write(uint16_t addr, uint8_t val, void *priv)
static uint8_t
sis_85c50x_isa_read(uint16_t addr, void *priv)
{
sis_85c50x_t *dev = (sis_85c50x_t *) priv;
uint8_t ret = 0xff;
const sis_85c50x_t *dev = (sis_85c50x_t *) priv;
uint8_t ret = 0xff;
switch (addr) {
case 0x22:

33
src/chipset/stpc.c
View File

@@ -166,8 +166,8 @@ stpc_host_write(uint16_t addr, uint8_t val, void *priv)
static uint8_t
stpc_host_read(uint16_t addr, void *priv)
{
stpc_t *dev = (stpc_t *) priv;
uint8_t ret;
const stpc_t *dev = (stpc_t *) priv;
uint8_t ret;
if (addr == dev->host_base)
ret = dev->host_offset;
@@ -196,8 +196,8 @@ stpc_localbus_write(uint16_t addr, uint8_t val, void *priv)
static uint8_t
stpc_localbus_read(uint16_t addr, void *priv)
{
stpc_t *dev = (stpc_t *) priv;
uint8_t ret;
const stpc_t *dev = (stpc_t *) priv;
uint8_t ret;
if (addr == dev->localbus_base)
ret = dev->localbus_offset;
@@ -260,8 +260,8 @@ stpc_nb_write(int func, int addr, uint8_t val, void *priv)
static uint8_t
stpc_nb_read(int func, int addr, void *priv)
{
stpc_t *dev = (stpc_t *) priv;
uint8_t ret;
const stpc_t *dev = (stpc_t *) priv;
uint8_t ret;
if (func > 0)
ret = 0xff;
@@ -445,8 +445,8 @@ stpc_ide_write(int func, int addr, uint8_t val, void *priv)
static uint8_t
stpc_ide_read(int func, int addr, void *priv)
{
stpc_t *dev = (stpc_t *) priv;
uint8_t ret;
const stpc_t *dev = (stpc_t *) priv;
uint8_t ret;
if (func > 0)
ret = 0xff;
@@ -507,8 +507,8 @@ stpc_isab_write(int func, int addr, uint8_t val, void *priv)
static uint8_t
stpc_isab_read(int func, int addr, void *priv)
{
stpc_t *dev = (stpc_t *) priv;
uint8_t ret;
const stpc_t *dev = (stpc_t *) priv;
uint8_t ret;
if ((func == 1) && (dev->local != STPC_ATLAS))
ret = stpc_ide_read(0, addr, priv);
@@ -571,8 +571,8 @@ stpc_usb_write(int func, int addr, uint8_t val, void *priv)
static uint8_t
stpc_usb_read(int func, int addr, void *priv)
{
stpc_t *dev = (stpc_t *) priv;
uint8_t ret;
const stpc_t *dev = (stpc_t *) priv;
uint8_t ret;
if (func > 0)
ret = 0xff;
@@ -614,7 +614,8 @@ stpc_remap_localbus(stpc_t *dev, uint16_t localbus_base)
static uint8_t
stpc_serial_handlers(uint8_t val)
{
stpc_serial_t *dev = device_get_priv(&stpc_serial_device);
const stpc_serial_t *dev = device_get_priv(&stpc_serial_device);
if (!dev) {
stpc_log("STPC: Not remapping UARTs, disabled by strap (raw %02X)\n", val);
return 0;
@@ -744,8 +745,8 @@ stpc_reg_write(uint16_t addr, uint8_t val, void *priv)
static uint8_t
stpc_reg_read(uint16_t addr, void *priv)
{
stpc_t *dev = (stpc_t *) priv;
uint8_t ret;
const stpc_t *dev = (stpc_t *) priv;
uint8_t ret;
if (addr == 0x22)
ret = dev->reg_offset;
@@ -895,7 +896,7 @@ stpc_setup(stpc_t *dev)
static void
stpc_usb_update_interrupt(usb_t* usb, void* priv)
{
stpc_t *dev = (stpc_t *) priv;
const stpc_t *dev = (stpc_t *) priv;
if (usb->irq_level)
pci_set_irq(dev->usb_slot, PCI_INTA);

4
src/chipset/umc_8886.c
View File

@@ -289,8 +289,8 @@ umc_8886_write(int func, int addr, uint8_t val, void *priv)
static uint8_t
umc_8886_read(int func, int addr, void *priv)
{
umc_8886_t *dev = (umc_8886_t *) priv;
uint8_t ret = 0xff;
const umc_8886_t *dev = (umc_8886_t *) priv;
uint8_t ret = 0xff;
if (func <= dev->max_func)
ret = dev->pci_conf_sb[func][addr];

4
src/chipset/umc_hb4.c
View File

@@ -333,8 +333,8 @@ hb4_write(UNUSED(int func), int addr, uint8_t val, void *priv)
static uint8_t
hb4_read(int func, int addr, void *priv)
{
hb4_t *dev = (hb4_t *) priv;
uint8_t ret = 0xff;
const hb4_t *dev = (hb4_t *) priv;
uint8_t ret = 0xff;
if (func == 0)
ret = dev->pci_conf[addr];

4
src/chipset/via_apollo.c
View File

@@ -671,8 +671,8 @@ via_apollo_host_bridge_write(int func, int addr, uint8_t val, void *priv)
static uint8_t
via_apollo_read(int func, int addr, void *priv)
{
via_apollo_t *dev = (via_apollo_t *) priv;
uint8_t ret = 0xff;
const via_apollo_t *dev = (via_apollo_t *) priv;
uint8_t ret = 0xff;
switch (func) {
case 0:

10
src/chipset/via_pipc.c
View File

@@ -750,8 +750,8 @@ pipc_codec_handlers(pipc_t *dev, uint8_t modem)
static uint8_t
pipc_fmnmi_read(uint16_t addr, void *priv)
{
pipc_t *dev = (pipc_t *) priv;
uint8_t ret = dev->fmnmi_regs[addr & 0x03];
const pipc_t *dev = (pipc_t *) priv;
uint8_t ret = dev->fmnmi_regs[addr & 0x03];
pipc_log("PIPC: fmnmi_read(%02X) = %02X\n", addr & 0x03, ret);
@@ -786,7 +786,7 @@ pipc_fmnmi_handlers(pipc_t *dev, uint8_t modem)
static uint8_t
pipc_fm_read(uint16_t addr, void *priv)
{
pipc_t *dev = (pipc_t *) priv;
const pipc_t *dev = (pipc_t *) priv;
#ifdef VIA_PIPC_FM_EMULATION
uint8_t ret = ((addr & 0x03) == 0x00) ? dev->fmnmi_status : 0x00;
#else
@@ -1474,7 +1474,9 @@ pipc_write(int func, int addr, uint8_t val, void *priv)
case 0xd2:
if (dev->local == VIA_PIPC_686B)
smbus_piix4_setclock(dev->smbus, (val & 0x04) ? 65536 : 16384);
/* fall-through */
#ifndef __APPLE__
[[fallthrough]];
#endif
case 0x90:
case 0x91:

4
src/chipset/via_vt82c49x.c
View File

@@ -296,8 +296,8 @@ vt82c49x_write(uint16_t addr, uint8_t val, void *priv)
static uint8_t
vt82c49x_read(uint16_t addr, void *priv)
{
uint8_t ret = 0xff;
vt82c49x_t *dev = (vt82c49x_t *) priv;
uint8_t ret = 0xff;
const vt82c49x_t *dev = (vt82c49x_t *) priv;
switch (addr) {
case 0xa9:

8
src/chipset/via_vt82c505.c
View File

@@ -126,8 +126,8 @@ vt82c505_write(int func, int addr, uint8_t val, void *priv)
static uint8_t
vt82c505_read(int func, int addr, void *priv)
{
vt82c505_t *dev = (vt82c505_t *) priv;
uint8_t ret = 0xff;
const vt82c505_t *dev = (vt82c505_t *) priv;
uint8_t ret = 0xff;
if (func != 0)
return ret;
@@ -151,8 +151,8 @@ vt82c505_out(uint16_t addr, uint8_t val, void *priv)
static uint8_t
vt82c505_in(uint16_t addr, void *priv)
{
vt82c505_t *dev = (vt82c505_t *) priv;
uint8_t ret = 0xff;
const vt82c505_t *dev = (vt82c505_t *) priv;
uint8_t ret = 0xff;
if ((addr == 0xa9) && (dev->index >= 0x80) && (dev->index <= 0x9f))
ret = vt82c505_read(0, dev->index, priv);

4
src/chipset/vl82c480.c
View File

@@ -137,8 +137,8 @@ vl82c480_write(uint16_t addr, uint8_t val, void *priv)
static uint8_t
vl82c480_read(uint16_t addr, void *priv)
{
vl82c480_t *dev = (vl82c480_t *) priv;
uint8_t ret = 0xff;
const vl82c480_t *dev = (vl82c480_t *) priv;
uint8_t ret = 0xff;
switch (addr) {
case 0xec:

3
src/chipset/wd76c10.c
View File

@@ -368,7 +368,8 @@ wd76c10_write(uint16_t addr, uint16_t val, void *priv)
static uint16_t
wd76c10_read(uint16_t addr, void *priv)
{
wd76c10_t *dev = (wd76c10_t *) priv;
const wd76c10_t *dev = (wd76c10_t *) priv;
wd76c10_log("WD76C10: R dev->regs[%04x]\n", addr);
switch (addr) {
case 0x1072:

30
src/config.c
View File

@@ -228,7 +228,7 @@ load_monitor(int monitor_index)
ini_section_t cat;
char name[512];
char temp[512];
char *p = NULL;
const char *p = NULL;
sprintf(name, "Monitor #%i", monitor_index + 1);
sprintf(temp, "%i, %i, %i, %i", cx, cy, cw, ch);
@@ -256,7 +256,7 @@ load_machine(void)
{
ini_section_t cat = ini_find_section(config, "Machine");
char *p;
char *migrate_from = NULL;
const char *migrate_from = NULL;
int c;
int i;
int j;
@@ -448,7 +448,7 @@ load_machine(void)
cpu_f = cpu_get_family(legacy_table_entry->family);
if (cpu_f) {
/* Save the new values. */
ini_section_set_string(cat, "cpu_family", (char *) legacy_table_entry->family);
ini_section_set_string(cat, "cpu_family", legacy_table_entry->family);
ini_section_set_int(cat, "cpu_speed", legacy_table_entry->rspeed);
ini_section_set_double(cat, "cpu_multi", legacy_table_entry->multi);
}
@@ -500,7 +500,7 @@ load_machine(void)
cpu_waitstates = ini_section_get_int(cat, "cpu_waitstates", 0);
p = (char *) ini_section_get_string(cat, "fpu_type", "none");
p = ini_section_get_string(cat, "fpu_type", "none");
fpu_type = fpu_get_type(cpu_f, cpu, p);
mem_size = ini_section_get_int(cat, "mem_size", 64);
@@ -911,7 +911,7 @@ load_ports(void)
lpt_ports[c].enabled = !!ini_section_get_int(cat, temp, (c == 0) ? 1 : 0);
sprintf(temp, "lpt%d_device", c + 1);
p = (char *) ini_section_get_string(cat, temp, "none");
p = ini_section_get_string(cat, temp, "none");
lpt_ports[c].device = lpt_device_get_from_internal_name(p);
}
@@ -1557,7 +1557,7 @@ load_other_removable_devices(void)
ini_section_t cat = ini_find_section(config, "Other removable devices");
char temp[512];
char tmp2[512];
char *p;
const char *p;
char s[512];
unsigned int board = 0;
unsigned int dev = 0;
@@ -2017,7 +2017,7 @@ save_general(void)
char temp[512];
char buffer[512] = { 0 };
char *va_name;
const char *va_name = NULL;
ini_section_set_int(cat, "vid_resize", vid_resize);
if (vid_resize == 0)
@@ -2216,7 +2216,7 @@ static void
save_machine(void)
{
ini_section_t cat = ini_find_or_create_section(config, "Machine");
char *p;
const char *p;
int c;
int i = 0;
int legacy_mfg;
@@ -2226,7 +2226,7 @@ save_machine(void)
p = machine_get_internal_name();
ini_section_set_string(cat, "machine", p);
ini_section_set_string(cat, "cpu_family", (char *) cpu_f->internal_name);
ini_section_set_string(cat, "cpu_family", cpu_f->internal_name);
ini_section_set_int(cat, "cpu_speed", cpu_f->cpus[cpu].rspeed);
ini_section_set_double(cat, "cpu_multi", cpu_f->cpus[cpu].multi);
if (cpu_override)
@@ -2247,14 +2247,14 @@ save_machine(void)
}
if (cpu_legacy_table[c].machine) {
/* Look for a corresponding CPU entry. */
cpu_legacy_table_t *legacy_table_entry;
const cpu_legacy_table_t *legacy_table_entry;
for (legacy_mfg = 0; legacy_mfg < 4; legacy_mfg++) {
if (!cpu_legacy_table[c].tables[legacy_mfg])
continue;
i = 0;
while (cpu_legacy_table[c].tables[legacy_mfg][i].family) {
legacy_table_entry = (cpu_legacy_table_t *) &cpu_legacy_table[c].tables[legacy_mfg][i];
legacy_table_entry = &cpu_legacy_table[c].tables[legacy_mfg][i];
/* Match the family name, speed and multiplier. */
if (!strcmp(cpu_f->internal_name, legacy_table_entry->family)) {
@@ -2294,7 +2294,7 @@ save_machine(void)
if (fpu_type == 0)
ini_section_delete_var(cat, "fpu_type");
else
ini_section_set_string(cat, "fpu_type", (char *) fpu_get_internal_name(cpu_f, cpu, fpu_type));
ini_section_set_string(cat, "fpu_type", fpu_get_internal_name(cpu_f, cpu, fpu_type));
// Write the mem_size explicitly to the setttings in order to help managers to display it without having the actual machine table
ini_section_delete_var(cat, "mem_size");
@@ -2613,7 +2613,7 @@ save_ports(void)
ini_section_delete_var(cat, temp);
else
ini_section_set_string(cat, temp,
(char *) lpt_device_get_internal_name(lpt_ports[c].device));
lpt_device_get_internal_name(lpt_ports[c].device));
}
ini_delete_section_if_empty(config, cat);
@@ -2738,7 +2738,7 @@ save_other_peripherals(void)
ini_section_delete_var(cat, temp);
else
ini_section_set_string(cat, temp,
(char *) isamem_get_internal_name(isamem_type[c]));
isamem_get_internal_name(isamem_type[c]));
}
if (isartc_type == 0)
@@ -2836,7 +2836,7 @@ save_hard_disks(void)
if (!hdd_is_valid(c) || (hdd[c].bus != HDD_BUS_IDE && hdd[c].bus != HDD_BUS_ESDI))
ini_section_delete_var(cat, temp);
else
ini_section_set_string(cat, temp, (char *) hdd_preset_get_internal_name(hdd[c].speed_preset));
ini_section_set_string(cat, temp, hdd_preset_get_internal_name(hdd[c].speed_preset));
}
ini_delete_section_if_empty(config, cat);

4
src/cpu/cpu.h
View File

@@ -133,13 +133,13 @@ enum {
# define LOOKUP_INV -1
#endif
typedef struct {
typedef struct fpu_t {
const char *name;
const char *internal_name;
const int type;
} FPU;
typedef struct {
typedef struct cpu_t {
const char *name;
uint64_t cpu_type;
const FPU *fpus;

16
src/ddma.c
View File

@@ -57,10 +57,10 @@ ddma_log(const char *fmt, ...)
static uint8_t
ddma_reg_read(uint16_t addr, void *priv)
{
ddma_channel_t *dev = (ddma_channel_t *) priv;
uint8_t ret = 0xff;
int ch = dev->channel;
int dmab = (ch >= 4) ? 0xc0 : 0x00;
const ddma_channel_t *dev = (ddma_channel_t *) priv;
uint8_t ret = 0xff;
int ch = dev->channel;
uint8_t dmab = (ch >= 4) ? 0xc0 : 0x00;
switch (addr & 0x0f) {
case 0x00:
@@ -92,10 +92,10 @@ ddma_reg_read(uint16_t addr, void *priv)
static void
ddma_reg_write(uint16_t addr, uint8_t val, void *priv)
{
ddma_channel_t *dev = (ddma_channel_t *) priv;
int ch = dev->channel;
int page_regs[4] = { 7, 3, 1, 2 };
int dmab = (ch >= 4) ? 0xc0 : 0x00;
const ddma_channel_t *dev = (ddma_channel_t *) priv;
int ch = dev->channel;
uint8_t page_regs[4] = { 7, 3, 1, 2 };
uint8_t dmab = (ch >= 4) ? 0xc0 : 0x00;
switch (addr & 0x0f) {
case 0x00:

42
src/device.c
View File

@@ -90,8 +90,8 @@ device_init(void)
void
device_set_context(device_context_t *c, const device_t *dev, int inst)
{
void *sec;
void *single_sec;
const void *sec;
void *single_sec;
memset(c, 0, sizeof(device_context_t));
c->dev = dev;
@@ -143,7 +143,7 @@ device_add_common(const device_t *dev, const device_t *cd, void *p, void *params
int c;
for (c = 0; c < 256; c++) {
if (!inst && (devices[c] == (device_t *) dev)) {
if (!inst && (devices[c] == dev)) {
device_log("DEVICE: device already exists!\n");
return (NULL);
}
@@ -343,23 +343,23 @@ device_get_priv(const device_t *dev)
int
device_available(const device_t *dev)
{
device_config_t *config = NULL;
device_config_bios_t *bios = NULL;
int roms_present = 0;
int i = 0;
const device_config_t *config = NULL;
const device_config_bios_t *bios = NULL;
int roms_present = 0;
int i = 0;
if (dev != NULL) {
config = (device_config_t *) dev->config;
config = dev->config;
if (config != NULL) {
while (config->type != -1) {
if (config->type == CONFIG_BIOS) {
bios = (device_config_bios_t *) config->bios;
bios = (const device_config_bios_t *) config->bios;
/* Go through the ROM's in the device configuration. */
while (bios->files_no != 0) {
i = 0;
for (int bf = 0; bf < bios->files_no; bf++)
i += !!rom_present((char *) bios->files[bf]);
i += !!rom_present(bios->files[bf]);
if (i == bios->files_no)
roms_present++;
bios++;
@@ -385,15 +385,15 @@ device_available(const device_t *dev)
const char *
device_get_bios_file(const device_t *dev, const char *internal_name, int file_no)
{
device_config_t *config = NULL;
device_config_bios_t *bios = NULL;
const device_config_t *config = NULL;
const device_config_bios_t *bios = NULL;
if (dev != NULL) {
config = (device_config_t *) dev->config;
config = dev->config;
if (config != NULL) {
while (config->type != -1) {
if (config->type == CONFIG_BIOS) {
bios = (device_config_bios_t *) config->bios;
bios = config->bios;
/* Go through the ROM's in the device configuration. */
while (bios->files_no != 0) {
@@ -418,8 +418,8 @@ device_get_bios_file(const device_t *dev, const char *internal_name, int file_no
int
device_has_config(const device_t *dev)
{
int c = 0;
device_config_t *config;
int c = 0;
const device_config_t *config;
if (dev == NULL)
return 0;
@@ -427,7 +427,7 @@ device_has_config(const device_t *dev)
if (dev->config == NULL)
return 0;
config = (device_config_t *) dev->config;
config = dev->config;
while (config->type != -1) {
if (config->type != CONFIG_MAC)
@@ -472,10 +472,10 @@ device_register_pci_slot(const device_t *dev, int device, int type, int inta, in
void
device_get_name(const device_t *dev, int bus, char *name)
{
char *sbus = NULL;
char *fbus;
char *tname;
char pbus[8] = { 0 };
const char *sbus = NULL;
const char *fbus;
char *tname;
char pbus[8] = { 0 };
if (dev == NULL)
return;

2
src/device/cartridge.c
View File

@@ -61,7 +61,7 @@ cartridge_log(const char *fmt, ...)
static uint8_t
cart_read(uint32_t addr, void *priv)
{
cart_t *dev = (cart_t *) priv;
const cart_t *dev = (cart_t *) priv;
return dev->buf[addr - dev->base];
}

4
src/device/hwm_lm78.c
View File

@@ -421,8 +421,8 @@ lm78_i2c_read(UNUSED(void *bus), UNUSED(uint8_t addr), void *priv)
uint8_t
lm78_as99127f_read(void *priv, uint8_t reg)
{
lm78_t *dev = (lm78_t *) priv;
uint8_t ret = dev->as99127f.regs[1][reg & 0x7f];
const lm78_t *dev = (lm78_t *) priv;
uint8_t ret = dev->as99127f.regs[1][reg & 0x7f];
lm78_log("LM78: read(%02X, AS99127F) = %02X\n", reg, ret);

4
src/device/hwm_vt82c686.c
View File

@@ -48,8 +48,8 @@ static void vt82c686_reset(vt82c686_t *dev, uint8_t initialization);
static uint8_t
vt82c686_read(uint16_t addr, void *priv)
{
vt82c686_t *dev = (vt82c686_t *) priv;
uint8_t ret;
const vt82c686_t *dev = (vt82c686_t *) priv;
uint8_t ret;
addr -= dev->io_base;

22
src/device/i2c.c
View File

@@ -205,9 +205,9 @@ i2c_handler(int set, void *bus_handle, uint8_t base, int size,
uint8_t
i2c_start(void *bus_handle, uint8_t addr, uint8_t read)
{
uint8_t ret = 0;
i2c_bus_t *bus = (i2c_bus_t *) bus_handle;
i2c_t *p;
uint8_t ret = 0;
const i2c_bus_t *bus = (i2c_bus_t *) bus_handle;
i2c_t *p;
if (!bus)
return ret;
@@ -230,9 +230,9 @@ i2c_start(void *bus_handle, uint8_t addr, uint8_t read)
uint8_t
i2c_read(void *bus_handle, uint8_t addr)
{
uint8_t ret = 0;
i2c_bus_t *bus = (i2c_bus_t *) bus_handle;
i2c_t *p;
uint8_t ret = 0;
const i2c_bus_t *bus = (i2c_bus_t *) bus_handle;
i2c_t *p;
if (!bus)
return ret;
@@ -256,9 +256,9 @@ i2c_read(void *bus_handle, uint8_t addr)
uint8_t
i2c_write(void *bus_handle, uint8_t addr, uint8_t data)
{
uint8_t ret = 0;
i2c_t *p;
i2c_bus_t *bus = (i2c_bus_t *) bus_handle;
uint8_t ret = 0;
i2c_t *p;
const i2c_bus_t *bus = (i2c_bus_t *) bus_handle;
if (!bus)
return ret;
@@ -281,8 +281,8 @@ i2c_write(void *bus_handle, uint8_t addr, uint8_t data)
void
i2c_stop(void *bus_handle, uint8_t addr)
{
i2c_bus_t *bus = (i2c_bus_t *) bus_handle;
i2c_t *p;
const i2c_bus_t *bus = (i2c_bus_t *) bus_handle;
i2c_t *p;
if (!bus)
return;

6
src/device/i2c_gpio.c
View File

@@ -171,14 +171,16 @@ i2c_gpio_set(void *dev_handle, uint8_t scl, uint8_t sda)
uint8_t
i2c_gpio_get_scl(void *dev_handle)
{
i2c_gpio_t *dev = (i2c_gpio_t *) dev_handle;
const i2c_gpio_t *dev = (i2c_gpio_t *) dev_handle;
return dev->prev_scl;
}
uint8_t
i2c_gpio_get_sda(void *dev_handle)
{
i2c_gpio_t *dev = (i2c_gpio_t *) dev_handle;
const i2c_gpio_t *dev = (i2c_gpio_t *) dev_handle;
i2c_gpio_log(3, "I2C GPIO %s: read myscl=%d mysda=%d slavesda=%d\n", dev->bus_name, dev->prev_scl, dev->prev_sda, dev->slave_sda);
return dev->prev_sda && dev->slave_sda;
}

4
src/device/ibm_5161.c
View File

@@ -45,8 +45,8 @@ ibm_5161_out(uint16_t port, uint8_t val, void *priv)
static uint8_t
ibm_5161_in(uint16_t port, void *priv)
{
ibm_5161_t *dev = (ibm_5161_t *) priv;
uint8_t ret = 0xff;
const ibm_5161_t *dev = (ibm_5161_t *) priv;
uint8_t ret = 0xff;
ret = dev->regs[port & 0x0007];

6
src/device/isamem.c
View File

@@ -288,9 +288,9 @@ ems_writew(uint32_t addr, uint16_t val, void *priv)
static uint8_t
ems_read(uint16_t port, void *priv)
{
memdev_t *dev = (memdev_t *) priv;
uint8_t ret = 0xff;
int vpage;
const memdev_t *dev = (memdev_t *) priv;
uint8_t ret = 0xff;
int vpage;
/* Get the viewport page number. */
vpage = (port / EMS_PGSIZE);

3
src/device/isapnp.c
View File

@@ -259,7 +259,8 @@ isapnp_reset_ld_regs(isapnp_device_t *ld)
static uint8_t
isapnp_read_rangecheck(UNUSED(uint16_t addr), void *priv)
{
isapnp_device_t *dev = (isapnp_device_t *) priv;
const isapnp_device_t *dev = (isapnp_device_t *) priv;
return (dev->regs[0x31] & 0x01) ? 0x55 : 0xaa;
}

23
src/device/isartc.c
View File

@@ -191,11 +191,11 @@ mm67_chkalrm(nvr_t *nvr, int8_t addr)
static void
mm67_tick(nvr_t *nvr)
{
rtcdev_t *dev = (rtcdev_t *) nvr->data;
uint8_t *regs = nvr->regs;
int mon;
int year;
int f = 0;
const rtcdev_t *dev = (rtcdev_t *) nvr->data;
uint8_t *regs = nvr->regs;
int mon;
int year;
int f = 0;
/* Update and set interrupt if needed. */
regs[MM67_SEC] = RTC_BCDINC(nvr->regs[MM67_SEC], 1);
@@ -295,8 +295,8 @@ mm67_tick(nvr_t *nvr)
static void
mm67_time_get(nvr_t *nvr, struct tm *tm)
{
rtcdev_t *dev = (rtcdev_t *) nvr->data;
uint8_t *regs = nvr->regs;
const rtcdev_t *dev = (rtcdev_t *) nvr->data;
const uint8_t *regs = nvr->regs;
/* NVR is in BCD data mode. */
tm->tm_sec = RTC_DCB(regs[MM67_SEC]);
@@ -325,9 +325,9 @@ mm67_time_get(nvr_t *nvr, struct tm *tm)
static void
mm67_time_set(nvr_t *nvr, struct tm *tm)
{
rtcdev_t *dev = (rtcdev_t *) nvr->data;
uint8_t *regs = nvr->regs;
int year;
const rtcdev_t *dev = (rtcdev_t *) nvr->data;
uint8_t *regs = nvr->regs;
int year;
/* NVR is in BCD data mode. */
regs[MM67_SEC] = RTC_BCD(tm->tm_sec);
@@ -608,9 +608,6 @@ isartc_close(void *priv)
io_removehandler(dev->base_addr, dev->base_addrsz,
dev->f_rd, NULL, NULL, dev->f_wr, NULL, NULL, dev);
if (dev->nvr.fn != NULL)
free(dev->nvr.fn);
free(dev);
}

16
src/device/kbc_at.c
View File

@@ -463,7 +463,9 @@ kbc_at_poll_at(atkbc_t *dev)
case STATE_KBC_AMI_OUT:
if (dev->status & STAT_OFULL)
break;
/* FALLTHROUGH */
#ifndef __APPLE__
[[fallthrough]];
#endif
case STATE_MAIN_IBF:
default:
at_main_ibf:
@@ -586,7 +588,9 @@ kbc_at_poll_ps2(atkbc_t *dev)
case STATE_KBC_AMI_OUT:
if (dev->status & STAT_OFULL)
break;
/* FALLTHROUGH */
#ifndef __APPLE__
[[fallthrough]];
#endif
case STATE_MAIN_IBF:
default:
ps2_main_ibf:
@@ -1027,6 +1031,9 @@ write64_generic(void *priv, uint8_t val)
kbc_at_log("ATkbc: pulse %01X\n", val & 0x0f);
pulse_output(dev, val & 0x0f);
return 0;
default:
break;
}
kbc_at_log("ATkbc: bad command %02X\n", val);
@@ -1328,12 +1335,13 @@ write64_siemens(void *priv, uint8_t val)
static uint8_t
write60_quadtel(void *priv, UNUSED(uint8_t val))
{
atkbc_t *dev = (atkbc_t *) priv;
const atkbc_t *dev = (atkbc_t *) priv;
switch (dev->command) {
case 0xcf: /*??? - sent by MegaPC BIOS*/
kbc_at_log("ATkbc: ??? - sent by MegaPC BIOS\n");
return 0;
default:
break;
}
@@ -1392,7 +1400,7 @@ write64_quadtel(void *priv, uint8_t val)
static uint8_t
write60_toshiba(void *priv, uint8_t val)
{
atkbc_t *dev = (atkbc_t *) priv;
const atkbc_t *dev = (atkbc_t *) priv;
switch (dev->command) {
case 0xb6: /* T3100e - set color/mono switch */

4
src/device/kbc_at_dev.c
View File

@@ -135,7 +135,9 @@ kbc_at_dev_poll(void *priv)
dev->port->wantcmd = 0;
break;
}
/* FALLTHROUGH */
#ifndef __APPLE__
[[fallthrough]];
#endif
case DEV_STATE_MAIN_WANT_IN:
/* Output command response and then return to main loop #2. */
if ((dev->port->out_new == -1) && (dev->cmd_queue_start != dev->cmd_queue_end)) {

12
src/device/keyboard.c
View File

@@ -87,8 +87,8 @@ fake_shift_needed(uint16_t scan)
void
key_process(uint16_t scan, int down)
{
scancode *codes = scan_table;
int c;
const scancode *codes = scan_table;
int c;
if (!codes)
return;
@@ -222,7 +222,7 @@ keyboard_input(int down, uint16_t scan)
static uint8_t
keyboard_do_break(uint16_t scan)
{
scancode *codes = scan_table;
const scancode *codes = scan_table;
/* TODO: The keyboard controller needs to report the AT flag to us here. */
if (is286 && ((keyboard_mode & 3) == 3)) {
@@ -266,7 +266,7 @@ keyboard_get_states(uint8_t *cl, uint8_t *nl, uint8_t *sl)
void
keyboard_set_states(uint8_t cl, uint8_t nl, uint8_t sl)
{
scancode *codes = scan_table;
const scancode *codes = scan_table;
int i;
@@ -320,7 +320,7 @@ keyboard_isfsenter(void)
}
int
keyboard_isfsenter_down(void)
keyboard_isfsenter_up(void)
{
return (!recv_key[0x01d] && !recv_key[0x11d] && !recv_key[0x038] && !recv_key[0x138] && !recv_key[0x049] && !recv_key[0x149]);
}
@@ -333,7 +333,7 @@ keyboard_isfsexit(void)
}
int
keyboard_isfsexit_down(void)
keyboard_isfsexit_up(void)
{
return (!recv_key[0x01d] && !recv_key[0x11d] && !recv_key[0x038] && !recv_key[0x138] && !recv_key[0x051] && !recv_key[0x151]);
}

4
src/device/keyboard_xt.c
View File

@@ -594,8 +594,8 @@ kbd_write(uint16_t port, uint8_t val, void *priv)
static uint8_t
kbd_read(uint16_t port, void *priv)
{
xtkbd_t *kbd = (xtkbd_t *) priv;
uint8_t ret = 0xff;
const xtkbd_t *kbd = (xtkbd_t *) priv;
uint8_t ret = 0xff;
switch (port) {
case 0x60: /* Keyboard Data Register (aka Port A) */

1
src/device/mouse_bus.c
View File

@@ -226,7 +226,6 @@ lt_read(uint16_t port, void *priv)
return (dev->control_val | 0x0F) & ~IRQ_MASK;
else
return 0xff;
break;
default:
break;

8
src/device/mouse_serial.c
View File

@@ -507,7 +507,9 @@ sermouse_command_timer(void *priv)
break;
case PHASE_ACK:
serial_write_fifo(dev->serial, 0x06);
/* FALLTHROUGH */
#ifndef __APPLE__
[[fallthrough]];
#endif
case PHASE_BAUD_RATE:
sermouse_command_phase_idle(dev);
sermouse_timer_on(dev, dev->report_period, 1);
@@ -645,7 +647,9 @@ ltsermouse_write(UNUSED(struct serial_s *serial), void *priv, uint8_t data)
switch (data) {
default:
mouse_serial_log("Serial mouse: Invalid period %02X, using 1200 bps\n", data);
/*FALLTHROUGH*/
#ifndef __APPLE__
[[fallthrough]];
#endif
case 0x6E:
dev->transmit_period = sermouse_transmit_period(dev, 1200, -1);
break;

4
src/device/pci_bridge.c
View File

@@ -363,8 +363,8 @@ pci_bridge_write(int func, int addr, uint8_t val, void *priv)
static uint8_t
pci_bridge_read(int func, int addr, void *priv)
{
pci_bridge_t *dev = (pci_bridge_t *) priv;
uint8_t ret;
const pci_bridge_t *dev = (pci_bridge_t *) priv;
uint8_t ret;
if (func > 0)
ret = 0xff;

3
src/device/phoenix_486_jumper.c
View File

@@ -78,7 +78,8 @@ phoenix_486_jumper_write(UNUSED(uint16_t addr), uint8_t val, void *priv)
static uint8_t
phoenix_486_jumper_read(UNUSED(uint16_t addr), void *priv)
{
phoenix_486_jumper_t *dev = (phoenix_486_jumper_t *) priv;
const phoenix_486_jumper_t *dev = (phoenix_486_jumper_t *) priv;
phoenix_486_jumper_log("Phoenix 486 Jumper: Read %02x\n", dev->jumper);
return dev->jumper;
}

4
src/device/smbus_ali7101.c
View File

@@ -193,7 +193,9 @@ smbus_ali7101_write(uint16_t addr, uint8_t val, void *priv)
case 0x4: /* block R/W */
timer_bytes++; /* count the SMBus length byte now */
/* fall-through */
#ifndef __APPLE__
[[fallthrough]];
#endif
default: /* unknown */
dev->next_stat = 0x20; /* raise DEV_ERR */

12
src/device/smbus_piix4.c
View File

@@ -195,7 +195,9 @@ smbus_piix4_write(uint16_t addr, uint8_t val, void *priv)
timer_bytes++;
}
/* fall-through */
#ifndef __APPLE__
[[fallthrough]];
#endif
case 0xc: /* I2C process call */
if (!read) { /* word write (only when writing) */
@@ -214,7 +216,9 @@ smbus_piix4_write(uint16_t addr, uint8_t val, void *priv)
case 0x5: /* block R/W */
timer_bytes++; /* count the SMBus length byte now */
/* fall-through */
#ifndef __APPLE__
[[fallthrough]];
#endif
case 0xd: /* I2C block R/W */
i2c_write(i2c_smbus, smbus_addr, dev->cmd);
@@ -247,7 +251,9 @@ smbus_piix4_write(uint16_t addr, uint8_t val, void *priv)
i2c_write(i2c_smbus, smbus_addr, dev->cmd);
timer_bytes++;
/* fall-through */
#ifndef __APPLE__
[[fallthrough]];
#endif
case 0xe: /* I2C with 7-bit address */
if (!read) { /* word write (only when writing) */

26
src/disk/hdc_esdi_at.c
View File

@@ -173,13 +173,13 @@ esdi_get_xfer_time(UNUSED(esdi_t *esdi), int size)
static int
get_sector(esdi_t *esdi, off64_t *addr)
{
drive_t *drive = &esdi->drives[esdi->drive_sel];
int heads = drive->cfg_hpc;
int sectors = drive->cfg_spt;
int c;
int h;
int s;
int sector;
const drive_t *drive = &esdi->drives[esdi->drive_sel];
int heads = drive->cfg_hpc;
int sectors = drive->cfg_spt;
int c;
int h;
int s;
int sector;
if (esdi->head > heads) {
esdi_at_log("esdi_get_sector: past end of configured heads\n");
@@ -338,7 +338,9 @@ esdi_write(uint16_t port, uint8_t val, void *priv)
esdi->command &= ~0x03;
if (val & 0x02)
fatal("Read with ECC\n");
/*FALLTHROUGH*/
#ifndef __APPLE__
[[fallthrough]];
#endif
case 0xa0:
esdi->status = STAT_BUSY;
@@ -397,7 +399,9 @@ esdi_write(uint16_t port, uint8_t val, void *priv)
default:
esdi_at_log("WD1007: bad command %02X\n", val);
/*FALLTHROUGH*/
#ifndef __APPLE__
[[fallthrough]];
#endif
case 0xe8: /*???*/
esdi->status = STAT_BUSY;
esdi_set_callback(esdi, 200 * HDC_TIME);
@@ -878,8 +882,8 @@ wd1007vse1_init(UNUSED(const device_t *info))
static void
wd1007vse1_close(void *priv)
{
esdi_t *esdi = (esdi_t *) priv;
drive_t *drive;
esdi_t *esdi = (esdi_t *) priv;
const drive_t *drive;
for (uint8_t d = 0; d < 2; d++) {
drive = &esdi->drives[d];

16
src/disk/hdc_esdi_mca.c
View File

@@ -352,10 +352,10 @@ complete_command_status(esdi_t *dev)
static void
esdi_callback(void *priv)
{
esdi_t *dev = (esdi_t *) priv;
drive_t *drive;
int val;
double cmd_time = 0.0;
esdi_t *dev = (esdi_t *) priv;
const drive_t *drive;
int val;
double cmd_time = 0.0;
esdi_mca_set_callback(dev, 0);
@@ -1059,7 +1059,7 @@ esdi_writew(uint16_t port, uint16_t val, void *priv)
static uint8_t
esdi_mca_read(int port, void *priv)
{
esdi_t *dev = (esdi_t *) priv;
const esdi_t *dev = (esdi_t *) priv;
esdi_mca_log("ESDI: mcard(%04x)\n", port);
@@ -1132,7 +1132,7 @@ esdi_mca_write(int port, uint8_t val, void *priv)
static uint8_t
esdi_mca_feedb(void *priv)
{
esdi_t *dev = (esdi_t *) priv;
const esdi_t *dev = (esdi_t *) priv;
return (dev->pos_regs[2] & 1);
}
@@ -1210,8 +1210,8 @@ esdi_init(UNUSED(const device_t *info))
static void
esdi_close(void *priv)
{
esdi_t *dev = (esdi_t *) priv;
drive_t *drive;
esdi_t *dev = (esdi_t *) priv;
const drive_t *drive;
dev->drives[0].present = dev->drives[1].present = 0;

68
src/disk/hdc_ide.c
View File

@@ -597,13 +597,13 @@ ide_hd_identify(ide_t *ide)
static void
ide_identify(ide_t *ide)
{
int d;
int i;
int max_pio;
int max_sdma;
int max_mdma;
int max_udma;
ide_t *ide_other = ide_drives[ide->channel ^ 1];
int d;
int i;
int max_pio;
int max_sdma;
int max_mdma;
int max_udma;
const ide_t *ide_other = ide_drives[ide->channel ^ 1];
ide_log("IDE IDENTIFY or IDENTIFY PACKET DEVICE on board %i (channel %i)\n", ide->board, ide->channel);
@@ -1114,8 +1114,8 @@ ide_atapi_packet_read(ide_t *ide, int length)
{
scsi_common_t *dev = ide->sc;
uint16_t *bufferw;
uint32_t *bufferl;
const uint16_t *bufferw;
const uint32_t *bufferl;
uint32_t temp = 0;
@@ -1311,7 +1311,7 @@ ide_writew(uint16_t addr, uint16_t val, void *priv)
static void
ide_writel(uint16_t addr, uint32_t val, void *priv)
{
ide_board_t *dev = (ide_board_t *) priv;
const ide_board_t *dev = (ide_board_t *) priv;
ide_t *ide;
int ch;
@@ -1655,7 +1655,9 @@ ide_writeb(uint16_t addr, uint8_t val, void *priv)
disabled, the Read Multiple operation is rejected with an Aborted Com-
mand error. */
ide->blockcount = 0;
/*FALLTHROUGH*/
#ifndef __APPLE__
[[fallthrough]];
#endif
case WIN_READ:
case WIN_READ_NORETRY:
@@ -1704,7 +1706,9 @@ ide_writeb(uint16_t addr, uint8_t val, void *priv)
/* Turn on the activity indicator *here* so that it gets turned on
less times. */
ui_sb_update_icon(SB_HDD | hdd[ide->hdd_num].bus, 1);
/*FALLTHROUGH*/
#ifndef __APPLE__
[[fallthrough]];
#endif
case WIN_WRITE:
case WIN_WRITE_NORETRY:
@@ -1843,6 +1847,9 @@ ide_bad_command:
return;
}
return;
default:
break;
}
}
@@ -1864,9 +1871,9 @@ ide_read_data(ide_t *ide, int length)
}
}
uint8_t *idebufferb = (uint8_t *) ide->buffer;
uint16_t *idebufferw = ide->buffer;
uint32_t *idebufferl = (uint32_t *) ide->buffer;
const uint8_t *idebufferb = (uint8_t *) ide->buffer;
const uint16_t *idebufferw = ide->buffer;
const uint32_t *idebufferl = (uint32_t *) ide->buffer;
if (ide->command == WIN_PACKETCMD) {
ide->pos = 0;
@@ -1946,7 +1953,7 @@ ide_status(ide_t *ide, ide_t *ide_other, int ch)
uint8_t
ide_readb(uint16_t addr, void *priv)
{
ide_board_t *dev = (ide_board_t *) priv;
const ide_board_t *dev = (ide_board_t *) priv;
int ch;
int absent = 0;
@@ -2062,6 +2069,9 @@ ide_readb(uint16_t addr, void *priv)
ide_irq_lower(ide);
temp = ide_status(ide, ide_drives[ch ^ 1], ch);
break;
default:
break;
}
ide_log("ide_readb(%04X, %08X) = %02X\n", addr, priv, temp);
@@ -2073,7 +2083,7 @@ ide_read_alt_status(UNUSED(uint16_t addr), void *priv)
{
uint8_t temp = 0xff;
ide_board_t *dev = (ide_board_t *) priv;
const ide_board_t *dev = (ide_board_t *) priv;
ide_t *ide;
int ch;
@@ -2094,7 +2104,7 @@ ide_readw(uint16_t addr, void *priv)
{
uint16_t temp = 0xffff;
ide_board_t *dev = (ide_board_t *) priv;
const ide_board_t *dev = (ide_board_t *) priv;
ide_t *ide;
int ch;
@@ -2124,7 +2134,7 @@ ide_readl(uint16_t addr, void *priv)
uint16_t temp2;
uint32_t temp = 0xffffffff;
ide_board_t *dev = (ide_board_t *) priv;
const ide_board_t *dev = (ide_board_t *) priv;
ide_t *ide;
int ch;
@@ -2620,11 +2630,11 @@ id_not_found:
uint8_t
ide_read_ali_75(void)
{
ide_t *ide0;
ide_t *ide1;
int ch0;
int ch1;
uint8_t ret = 0x00;
const ide_t *ide0;
const ide_t *ide1;
int ch0;
int ch1;
uint8_t ret = 0x00;
ch0 = ide_boards[0]->cur_dev;
ch1 = ide_boards[1]->cur_dev;
@@ -2646,11 +2656,11 @@ ide_read_ali_75(void)
uint8_t
ide_read_ali_76(void)
{
ide_t *ide0;
ide_t *ide1;
int ch0;
int ch1;
uint8_t ret = 0x00;
const ide_t *ide0;
const ide_t *ide1;
int ch0;
int ch1;
uint8_t ret = 0x00;
ch0 = ide_boards[0]->cur_dev;
ch1 = ide_boards[1]->cur_dev;

2
src/disk/hdc_ide_cmd646.c
View File

@@ -90,7 +90,7 @@ cmd646_set_irq(int channel, void *priv)
static int
cmd646_bus_master_dma(int channel, uint8_t *data, int transfer_length, int out, void *priv)
{
cmd646_t *dev = (cmd646_t *) priv;
const cmd646_t *dev = (cmd646_t *) priv;
return sff_bus_master_dma(channel, data, transfer_length, out, dev->bm[channel & 0x01]);
}

4
src/disk/hdc_ide_opti611.c
View File

@@ -93,8 +93,8 @@ opti611_cfg_writel(uint16_t addr, uint32_t val, void *priv)
static uint8_t
opti611_cfg_read(uint16_t addr, void *priv)
{
uint8_t ret = 0xff;
opti611_t *dev = (opti611_t *) priv;
uint8_t ret = 0xff;
const opti611_t *dev = (opti611_t *) priv;
addr &= 0x0007;

6
src/disk/hdc_ide_sff8038i.c
View File

@@ -222,7 +222,7 @@ sff_bus_master_writel(uint16_t port, uint32_t val, void *priv)
uint8_t
sff_bus_master_read(uint16_t port, void *priv)
{
sff8038i_t *dev = (sff8038i_t *) priv;
const sff8038i_t *dev = (sff8038i_t *) priv;
uint8_t ret = 0xff;
@@ -261,7 +261,7 @@ sff_bus_master_read(uint16_t port, void *priv)
static uint16_t
sff_bus_master_readw(uint16_t port, void *priv)
{
sff8038i_t *dev = (sff8038i_t *) priv;
const sff8038i_t *dev = (sff8038i_t *) priv;
uint16_t ret = 0xffff;
@@ -290,7 +290,7 @@ sff_bus_master_readw(uint16_t port, void *priv)
static uint32_t
sff_bus_master_readl(uint16_t port, void *priv)
{
sff8038i_t *dev = (sff8038i_t *) priv;
const sff8038i_t *dev = (sff8038i_t *) priv;
uint32_t ret = 0xffffffff;

4
src/disk/hdc_st506_at.c
View File

@@ -171,7 +171,7 @@ irq_update(mfm_t *mfm)
static int
get_sector(mfm_t *mfm, off64_t *addr)
{
drive_t *drive = &mfm->drives[mfm->drvsel];
const drive_t *drive = &mfm->drives[mfm->drvsel];
/* FIXME: See if this is even needed - if the code is present, IBM AT
diagnostics v2.07 will error with: ERROR 152 - SYSTEM BOARD. */
@@ -734,7 +734,7 @@ mfm_close(void *priv)
mfm_t *mfm = (mfm_t *) priv;
for (uint8_t d = 0; d < 2; d++) {
drive_t *drive = &mfm->drives[d];
const drive_t *drive = &mfm->drives[d];
hdd_image_close(drive->hdd_num);
}

24
src/disk/hdc_st506_xt.c
View File

@@ -623,6 +623,10 @@ st506_callback(void *priv)
st506_complete(dev);
break;
}
#ifndef __APPLE__
[[fallthrough]];
#endif
case CMD_FORMAT_TRACK:
case CMD_FORMAT_BAD_TRACK:
switch (dev->state) {
@@ -1377,10 +1381,10 @@ mem_write(uint32_t addr, uint8_t val, void *priv)
static uint8_t
mem_read(uint32_t addr, void *priv)
{
hdc_t *dev = (hdc_t *) priv;
uint32_t ptr;
uint32_t mask = 0;
uint8_t ret = 0xff;
const hdc_t *dev = (hdc_t *) priv;
uint32_t ptr;
uint32_t mask = 0;
uint8_t ret = 0xff;
/* Ignore accesses to anything below the configured address,
needed because of the emulator's 4k mapping granularity. */
@@ -1529,8 +1533,8 @@ loadhd(hdc_t *dev, int c, int d, UNUSED(const char *fn))
static void
set_switches(hdc_t *dev, hd_type_t *hdt, int num)
{
drive_t *drive;
int e;
const drive_t *drive;
int e;
dev->switches = 0x00;
@@ -1604,7 +1608,9 @@ st506_init(const device_t *info)
case ST506_XT_TYPE_ST11R: /* Seagate ST-11R (RLL) */
dev->spt = RLL_SECTORS;
/*FALLTHROUGH*/
#ifndef __APPLE__
[[fallthrough]];
#endif
case ST506_XT_TYPE_ST11M: /* Seagate ST-11M (MFM) */
dev->nr_err = ERR_NOT_AVAILABLE;
@@ -1778,8 +1784,8 @@ st506_init(const device_t *info)
static void
st506_close(void *priv)
{
hdc_t *dev = (hdc_t *) priv;
drive_t *drive;
hdc_t *dev = (hdc_t *) priv;
const drive_t *drive;
for (uint8_t d = 0; d < MFM_NUM; d++) {
drive = &dev->drives[d];

16
src/disk/hdc_xta.c
View File

@@ -509,7 +509,9 @@ hdc_callback(void *priv)
case CMD_READ_VERIFY:
no_data = 1;
/*FALLTHROUGH*/
#ifndef __APPLE__
[[fallthrough]];
#endif
case CMD_READ_SECTORS:
if (!drive->present) {
@@ -534,7 +536,9 @@ hdc_callback(void *priv)
dev->buf_len = 512;
dev->state = STATE_SEND;
/*FALLTHROUGH*/
#ifndef __APPLE__
[[fallthrough]];
#endif
case STATE_SEND:
/* Activate the status icon. */
@@ -642,7 +646,9 @@ do_send:
dev->buf_len = 512;
dev->state = STATE_RECV;
/*FALLTHROUGH*/
#ifndef __APPLE__
[[fallthrough]];
#endif
case STATE_RECV:
/* Activate the status icon. */
@@ -1098,8 +1104,8 @@ xta_init(const device_t *info)
static void
xta_close(void *priv)
{
hdc_t *dev = (hdc_t *) priv;
drive_t *drive;
hdc_t *dev = (hdc_t *) priv;
const drive_t *drive;
/* Remove the I/O handler. */
io_removehandler(dev->base, 4,

4
src/disk/hdd.c
View File

@@ -160,7 +160,7 @@ hdd_seek_get_time(hard_disk_t *hdd, uint32_t dst_addr, uint8_t operation, uint8_
if (!hdd->speed_preset)
return HDD_OVERHEAD_TIME;
hdd_zone_t *zone = NULL;
const hdd_zone_t *zone = NULL;
if (hdd->num_zones <= 0) {
fatal("hdd_seek_get_time(): hdd->num_zones < 0)\n");
return 0.0;
@@ -486,7 +486,7 @@ hdd_preset_apply(int hdd_id)
if (hd->speed_preset >= hdd_preset_get_num())
hd->speed_preset = 0;
hdd_preset_t *preset = &hdd_speed_presets[hd->speed_preset];
const hdd_preset_t *preset = &hdd_speed_presets[hd->speed_preset];
hd->cache.num_segments = preset->rcache_num_seg;
hd->cache.segment_size = preset->rcache_seg_size;

10
src/disk/mo.c
View File

@@ -655,7 +655,9 @@ mo_update_request_length(mo_t *dev, int len, int block_len)
break;
}
}
/*FALLTHROUGH*/
#ifndef __APPLE__
[[fallthrough]];
#endif
default:
dev->packet_len = len;
break;
@@ -1342,7 +1344,9 @@ mo_command(scsi_common_t *sc, uint8_t *cdb)
mo_invalid_field(dev);
return;
}
/*FALLTHROUGH*/
#ifndef __APPLE__
[[fallthrough]];
#endif
case GPCMD_SCSI_RESERVE:
case GPCMD_SCSI_RELEASE:
case GPCMD_TEST_UNIT_READY:
@@ -2051,7 +2055,7 @@ mo_do_identify(ide_t *ide, int ide_has_dma)
{
char model[40];
mo_t *mo = (mo_t *) ide->sc;
const mo_t *mo = (mo_t *) ide->sc;
memset(model, 0, 40);

14
src/disk/zip.c
View File

@@ -821,7 +821,10 @@ zip_update_request_length(zip_t *dev, int len, int block_len)
break;
}
}
/*FALLTHROUGH*/
#ifndef __APPLE__
[[fallthrough]];
#endif
default:
dev->packet_len = len;
break;
@@ -1408,7 +1411,9 @@ zip_command(scsi_common_t *sc, uint8_t *cdb)
zip_invalid_field(dev);
return;
}
/*FALLTHROUGH*/
#ifndef __APPLE__
[[fallthrough]];
#endif
case GPCMD_SCSI_RESERVE:
case GPCMD_SCSI_RELEASE:
case GPCMD_TEST_UNIT_READY:
@@ -1571,6 +1576,9 @@ zip_command(scsi_common_t *sc, uint8_t *cdb)
zip_command_complete(dev);
break;
}
#ifndef __APPLE__
[[fallthrough]];
#endif
case GPCMD_WRITE_6:
case GPCMD_WRITE_10:
case GPCMD_WRITE_AND_VERIFY_10:
@@ -2280,7 +2288,7 @@ zip_250_identify(ide_t *ide, int ide_has_dma)
static void
zip_identify(ide_t *ide, int ide_has_dma)
{
zip_t *zip;
const zip_t *zip;
zip = (zip_t *) ide->sc;

18
src/dma.c
View File

@@ -118,7 +118,7 @@ dma_sg_next_addr(dma_t *dev)
dev->eot = dev->count >> 31;
dev->count &= 0xfffe;
dev->cb = (uint16_t) dev->count;
dev->cc = (int) dev->count;
dev->cc = dev->count;
if (!dev->count)
dev->count = 65536;
if (ts == 2)
@@ -133,9 +133,7 @@ dma_sg_next_addr(dma_t *dev)
static void
dma_block_transfer(int channel)
{
int bit16;
bit16 = (channel >= 4);
int bit16 = (channel >= 4);
if (dma_advanced)
bit16 = !!(dma_transfer_size(&(dma[channel])) == 2);
@@ -300,7 +298,7 @@ dma_sg_writel(uint16_t port, uint32_t val, void *priv)
static uint8_t
dma_sg_read(uint16_t port, void *priv)
{
dma_t *dev = (dma_t *) priv;
const dma_t *dev = (dma_t *) priv;
uint8_t ret = 0xff;
@@ -348,7 +346,7 @@ dma_sg_read(uint16_t port, void *priv)
static uint16_t
dma_sg_readw(uint16_t port, void *priv)
{
dma_t *dev = (dma_t *) priv;
const dma_t *dev = (dma_t *) priv;
uint16_t ret = 0xffff;
@@ -382,7 +380,7 @@ dma_sg_readw(uint16_t port, void *priv)
static uint32_t
dma_sg_readl(uint16_t port, void *priv)
{
dma_t *dev = (dma_t *) priv;
const dma_t *dev = (dma_t *) priv;
uint32_t ret = 0xffffffff;
@@ -596,7 +594,7 @@ dma_write(uint16_t addr, uint8_t val, UNUSED(void *priv))
static uint8_t
dma_ps2_read(uint16_t addr, UNUSED(void *priv))
{
dma_t *dma_c = &dma[dma_ps2.xfr_channel];
const dma_t *dma_c = &dma[dma_ps2.xfr_channel];
uint8_t temp = 0xff;
switch (addr) {
@@ -1280,7 +1278,7 @@ dma_sg(uint8_t *data, int transfer_length, int out, void *priv)
uint8_t
_dma_read(uint32_t addr, dma_t *dma_c)
{
uint8_t temp;
uint8_t temp = 0;
if (dma_advanced) {
if (dma_c->sg_status & 1)
@@ -1296,7 +1294,7 @@ _dma_read(uint32_t addr, dma_t *dma_c)
static uint16_t
_dma_readw(uint32_t addr, dma_t *dma_c)
{
uint16_t temp;
uint16_t temp = 0;
if (dma_advanced) {
if (dma_c->sg_status & 1)

2
src/fifo8.c
View File

@@ -84,7 +84,7 @@ fifo8_pop(Fifo8 *fifo)
const uint8_t *
fifo8_pop_buf(Fifo8 *fifo, uint32_t max, uint32_t *num)
{
uint8_t *ret;
const uint8_t *ret;
assert(max > 0 && max <= fifo->num);
*num = MIN(fifo->capacity - fifo->head, max);

12
src/floppy/fdc.c
View File

@@ -916,7 +916,9 @@ fdc_write(uint16_t addr, uint8_t val, void *priv)
fdc_bad_command(fdc);
break;
}
/*FALLTHROUGH*/
#ifndef __APPLE__
[[fallthrough]];
#endif
case 0x07: /*Recalibrate*/
fdc->pnum = 0;
fdc->ptot = 1;
@@ -959,7 +961,9 @@ fdc_write(uint16_t addr, uint8_t val, void *priv)
fdc_bad_command(fdc);
break;
}
/*FALLTHROUGH*/
#ifndef __APPLE__
[[fallthrough]];
#endif
case 0x10: /*Get version*/
case 0x14: /*Unlock*/
case 0x94: /*Lock*/
@@ -1081,7 +1085,9 @@ fdc_write(uint16_t addr, uint8_t val, void *priv)
case 0x16: /* Verify */
if (fdc->params[0] & 0x80)
fdc->sc = fdc->params[7];
/*FALLTHROUGH*/
#ifndef __APPLE__
[[fallthrough]];
#endif
case 0x06: /* Read data */
case 0x0c: /* Read deleted data */
fdc_io_command_phase1(fdc, 0);

17
src/floppy/fdd.c
View File

@@ -64,7 +64,7 @@
#define FLAG_IGNORE_DENSEL 512
#define FLAG_PS2 1024
typedef struct {
typedef struct fdd_t {
int type;
int track;
int densel;
@@ -451,10 +451,10 @@ fdd_get_densel(int drive)
void
fdd_load(int drive, char *fn)
{
int c = 0;
int size;
char *p;
FILE *f;
int c = 0;
int size;
const char *p;
FILE * f;
fdd_log("FDD: loading drive %d with '%s'\n", drive, fn);
@@ -548,8 +548,8 @@ fdd_set_motor_enable(int drive, int motor_enable)
static void
fdd_poll(void *priv)
{
int drive;
DRIVE *drv = (DRIVE *) priv;
int drive;
const DRIVE *drv = (DRIVE *) priv;
drive = drv->id;
@@ -586,6 +586,9 @@ fdd_get_bitcell_period(int rate)
case 3: /*Extended density*/
bit_rate = 1000;
break;
default:
break;
}
return 1000000 / bit_rate * 2; /*Bitcell period in ns*/

282
src/floppy/fdd_86f.c
View File

@@ -180,7 +180,7 @@ typedef struct sector_t {
* specifies the entire bitcell count
*/
typedef struct d86f_t {
FILE *f;
FILE *fp;
uint8_t state;
uint8_t fill;
uint8_t sector_count;
@@ -355,7 +355,7 @@ d86f_reverse_bytes(int drive)
uint16_t
d86f_disk_flags(int drive)
{
d86f_t *dev = d86f[drive];
const d86f_t *dev = d86f[drive];
return dev->disk_flags;
}
@@ -363,7 +363,7 @@ d86f_disk_flags(int drive)
uint32_t
d86f_index_hole_pos(int drive, int side)
{
d86f_t *dev = d86f[drive];
const d86f_t *dev = d86f[drive];
return dev->index_hole_pos[side];
}
@@ -413,7 +413,7 @@ null_format_conditions(UNUSED(int drive))
int32_t
d86f_extra_bit_cells(int drive, int side)
{
d86f_t *dev = d86f[drive];
const d86f_t *dev = d86f[drive];
return dev->extra_bit_cells[side];
}
@@ -441,8 +441,8 @@ common_read_revolution(UNUSED(int drive))
uint16_t
d86f_side_flags(int drive)
{
d86f_t *dev = d86f[drive];
int side;
const d86f_t *dev = d86f[drive];
int side;
side = fdd_get_head(drive);
@@ -811,9 +811,9 @@ d86f_is_mfm(int drive)
uint32_t
d86f_get_data_len(int drive)
{
d86f_t *dev = d86f[drive];
uint32_t i;
uint32_t ret = 128;
const d86f_t *dev = d86f[drive];
uint32_t i;
uint32_t ret = 128;
if (dev->req_sector.id.n)
ret = (uint32_t) 128 << dev->req_sector.id.n;
@@ -1243,8 +1243,8 @@ d86f_calccrc(d86f_t *dev, uint8_t byte)
int
d86f_word_is_aligned(int drive, int side, uint32_t base_pos)
{
d86f_t *dev = d86f[drive];
uint32_t adjusted_track_pos = dev->track_pos;
const d86f_t *dev = d86f[drive];
uint32_t adjusted_track_pos = dev->track_pos;
if (base_pos == 0xFFFFFFFF)
return 0;
@@ -1659,7 +1659,7 @@ d86f_write_sector_data(int drive, int side, int mfm, uint16_t am)
d86f_handler[drive].write_data(drive, side, dev->data_find.bytes_obtained - 1, dev->current_byte[side]);
} else {
/* We're in the data field of the sector, use a CRC byte. */
dev->current_byte[side] = dev->calc_crc.bytes[(dev->data_find.bytes_obtained & 1)];
dev->current_byte[side] = dev->calc_crc.bytes[dev->data_find.bytes_obtained & 1];
}
dev->current_bit[side] = (15 - (dev->data_find.bits_obtained & 15)) >> 1;
@@ -1841,7 +1841,7 @@ d86f_write_direct_common(int drive, int side, uint16_t byte, uint8_t type, uint3
void
d86f_write_direct(int drive, int side, uint16_t byte, uint8_t type)
{
d86f_t *dev = d86f[drive];
const d86f_t *dev = d86f[drive];
d86f_write_direct_common(drive, side, byte, type, dev->track_pos >> 4);
}
@@ -1951,7 +1951,9 @@ d86f_format_track(int drive, int side, int do_write)
if (dev->datac == 3)
fdc_stop_id_request(d86f_fdc);
}
/*FALLTHROUGH*/
#ifndef __APPLE__
[[fallthrough]];
#endif
case FMT_PRETRK_SYNC:
case FMT_SECTOR_DATA_SYNC:
@@ -2106,9 +2108,9 @@ d86f_initialize_last_sector_id(int drive, int c, int h, int r, int n)
static uint8_t
d86f_sector_flags(int drive, int side, uint8_t c, uint8_t h, uint8_t r, uint8_t n)
{
d86f_t *dev = d86f[drive];
sector_t *s;
sector_t *t;
const d86f_t *dev = d86f[drive];
sector_t *s;
sector_t *t;
if (dev->last_side_sector[side]) {
s = dev->last_side_sector[side];
@@ -2257,9 +2259,9 @@ d86f_turbo_format(int drive, int side, int nop)
int
d86f_sector_is_present(int drive, int side, uint8_t c, uint8_t h, uint8_t r, uint8_t n)
{
d86f_t *dev = d86f[drive];
sector_t *s;
sector_t *t;
const d86f_t *dev = d86f[drive];
sector_t *s;
sector_t *t;
if (dev->last_side_sector[side]) {
s = dev->last_side_sector[side];
@@ -2294,7 +2296,9 @@ d86f_turbo_poll(int drive, int side)
case STATE_0D_SPIN_TO_INDEX:
dev->sector_count = 0;
dev->datac = 5;
/*FALLTHROUGH*/
#ifndef __APPLE__
[[fallthrough]];
#endif
case STATE_02_SPIN_TO_INDEX:
dev->state++;
@@ -2339,7 +2343,9 @@ d86f_turbo_poll(int drive, int side)
dev->last_sector.id.r = dev->req_sector.id.r;
dev->last_sector.id.n = dev->req_sector.id.n;
d86f_handler[drive].set_sector(drive, side, dev->last_sector.id.c, dev->last_sector.id.h, dev->last_sector.id.r, dev->last_sector.id.n);
/*FALLTHROUGH*/
#ifndef __APPLE__
[[fallthrough]];
#endif
case STATE_0A_FIND_ID:
dev->turbo_pos = 0;
@@ -2800,22 +2806,22 @@ d86f_construct_encoded_buffer(int drive, int side)
/* *_fuzm are fuzzy bit masks, *_holm are hole masks, dst_neim are masks is mask for bits that are neither fuzzy nor holes in both,
and src1_d and src2_d are filtered source data. */
uint16_t src1_fuzm;
uint16_t src2_fuzm;
uint16_t dst_fuzm;
uint16_t src1_holm;
uint16_t src2_holm;
uint16_t dst_holm;
uint16_t dst_neim;
uint16_t src1_d;
uint16_t src2_d;
uint32_t len;
uint16_t *dst = dev->track_encoded_data[side];
uint16_t *dst_s = dev->track_surface_data[side];
uint16_t *src1 = dev->thin_track_encoded_data[0][side];
uint16_t *src1_s = dev->thin_track_surface_data[0][side];
uint16_t *src2 = dev->thin_track_encoded_data[1][side];
uint16_t *src2_s = dev->thin_track_surface_data[1][side];
uint16_t src1_fuzm;
uint16_t src2_fuzm;
uint16_t dst_fuzm;
uint16_t src1_holm;
uint16_t src2_holm;
uint16_t dst_holm;
uint16_t dst_neim;
uint16_t src1_d;
uint16_t src2_d;
uint32_t len;
uint16_t *dst = dev->track_encoded_data[side];
uint16_t *dst_s = dev->track_surface_data[side];
const uint16_t *src1 = dev->thin_track_encoded_data[0][side];
const uint16_t *src1_s = dev->thin_track_surface_data[0][side];
const uint16_t *src2 = dev->thin_track_encoded_data[1][side];
const uint16_t *src2_s = dev->thin_track_surface_data[1][side];
len = d86f_get_array_size(drive, side, 1);
for (uint32_t i = 0; i < len; i++) {
@@ -2852,17 +2858,17 @@ d86f_construct_encoded_buffer(int drive, int side)
void
d86f_decompose_encoded_buffer(int drive, int side)
{
d86f_t *dev = d86f[drive];
uint16_t temp;
uint16_t temp2;
uint32_t len;
uint16_t *dst = dev->track_encoded_data[side];
uint16_t *src1 = dev->thin_track_encoded_data[0][side];
uint16_t *src1_s = dev->thin_track_surface_data[0][side];
uint16_t *src2 = dev->thin_track_encoded_data[1][side];
uint16_t *src2_s = dev->thin_track_surface_data[1][side];
dst = d86f_handler[drive].encoded_data(drive, side);
len = d86f_get_array_size(drive, side, 1);
d86f_t *dev = d86f[drive];
uint16_t temp;
uint16_t temp2;
uint32_t len;
const uint16_t *dst = dev->track_encoded_data[side];
uint16_t *src1 = dev->thin_track_encoded_data[0][side];
uint16_t *src1_s = dev->thin_track_surface_data[0][side];
uint16_t *src2 = dev->thin_track_encoded_data[1][side];
uint16_t *src2_s = dev->thin_track_surface_data[1][side];
dst = d86f_handler[drive].encoded_data(drive, side);
len = d86f_get_array_size(drive, side, 1);
for (uint32_t i = 0; i < len; i++) {
if (d86f_has_surface_desc(drive)) {
@@ -2905,12 +2911,12 @@ d86f_read_track(int drive, int track, int thin_track, int side, uint16_t *da, ui
if (dev->track_offset[logical_track]) {
if (!thin_track) {
if (fseek(dev->f, dev->track_offset[logical_track], SEEK_SET) == -1)
if (fseek(dev->fp, dev->track_offset[logical_track], SEEK_SET) == -1)
fatal("d86f_read_track(): Error seeking to offset dev->track_offset[logical_track]\n");
if (fread(&(dev->side_flags[side]), 1, 2, dev->f) != 2)
if (fread(&(dev->side_flags[side]), 1, 2, dev->fp) != 2)
fatal("d86f_read_track(): Error reading side flags\n");
if (d86f_has_extra_bit_cells(drive)) {
if (fread(&(dev->extra_bit_cells[side]), 1, 4, dev->f) != 4)
if (fread(&(dev->extra_bit_cells[side]), 1, 4, dev->fp) != 4)
fatal("d86f_read_track(): Error reading number of extra bit cells\n");
/* If RPM shift is 0% and direction is 1, do not adjust extra bit cells,
as that is the whole track length. */
@@ -2922,13 +2928,13 @@ d86f_read_track(int drive, int track, int thin_track, int side, uint16_t *da, ui
}
} else
dev->extra_bit_cells[side] = 0;
(void) !fread(&(dev->index_hole_pos[side]), 4, 1, dev->f);
(void) !fread(&(dev->index_hole_pos[side]), 4, 1, dev->fp);
} else
fseek(dev->f, dev->track_offset[logical_track] + d86f_track_header_size(drive), SEEK_SET);
fseek(dev->fp, dev->track_offset[logical_track] + d86f_track_header_size(drive), SEEK_SET);
array_size = d86f_get_array_size(drive, side, 0);
(void) !fread(da, 1, array_size, dev->f);
(void) !fread(da, 1, array_size, dev->fp);
if (d86f_has_surface_desc(drive))
(void) !fread(sa, 1, array_size, dev->f);
(void) !fread(sa, 1, array_size, dev->fp);
} else {
if (!thin_track) {
switch ((dev->disk_flags >> 1) & 3) {
@@ -3125,22 +3131,22 @@ d86f_writeback(int drive)
#endif
header_size = d86f_header_size(drive);
if (!dev->f)
if (!dev->fp)
return;
/* First write the track offsets table. */
if (fseek(dev->f, 0, SEEK_SET) == -1)
if (fseek(dev->fp, 0, SEEK_SET) == -1)
fatal("86F write_back(): Error seeking to the beginning of the file\n");
if (fread(header, 1, header_size, dev->f) != header_size)
if (fread(header, 1, header_size, dev->fp) != header_size)
fatal("86F write_back(): Error reading header size\n");
if (fseek(dev->f, 8, SEEK_SET) == -1)
if (fseek(dev->fp, 8, SEEK_SET) == -1)
fatal("86F write_back(): Error seeking\n");
size = d86f_get_track_table_size(drive);
if (fwrite(dev->track_offset, 1, size, dev->f) != size)
if (fwrite(dev->track_offset, 1, size, dev->fp) != size)
fatal("86F write_back(): Error writing data\n");
d86f_write_tracks(drive, &dev->f, NULL);
d86f_write_tracks(drive, &dev->fp, NULL);
#ifdef D86F_COMPRESS
if (dev->is_compressed) {
@@ -3152,16 +3158,16 @@ d86f_writeback(int drive)
/* Write the header to the original file. */
fwrite(header, 1, header_size, cf);
fseek(dev->f, 0, SEEK_END);
len = ftell(dev->f);
fseek(dev->fp, 0, SEEK_END);
len = ftell(dev->fp);
len -= header_size;
fseek(dev->f, header_size, SEEK_SET);
fseek(dev->fp, header_size, SEEK_SET);
/* Compress data from the temporary uncompressed file to the original, compressed file. */
dev->filebuf = (uint8_t *) malloc(len);
dev->outbuf = (uint8_t *) malloc(len - 1);
fread(dev->filebuf, 1, len, dev->f);
fread(dev->filebuf, 1, len, dev->fp);
ret = lzf_compress(dev->filebuf, len, dev->outbuf, len - 1);
if (!ret)
@@ -3421,7 +3427,7 @@ d86f_export(int drive, char *fn)
uint32_t tt[512];
d86f_t *dev = d86f[drive];
d86f_t *temp86;
FILE *f;
FILE *fp;
int tracks = 86;
int inc = 1;
uint32_t magic = 0x46423638;
@@ -3430,19 +3436,19 @@ d86f_export(int drive, char *fn)
memset(tt, 0, 512 * sizeof(uint32_t));
f = plat_fopen(fn, "wb");
if (!f)
fp = plat_fopen(fn, "wb");
if (!fp)
return 0;
/* Allocate a temporary drive for conversion. */
temp86 = (d86f_t *) malloc(sizeof(d86f_t));
memcpy(temp86, dev, sizeof(d86f_t));
fwrite(&magic, 4, 1, f);
fwrite(&version, 2, 1, f);
fwrite(&disk_flags, 2, 1, f);
fwrite(&magic, 4, 1, fp);
fwrite(&version, 2, 1, fp);
fwrite(&disk_flags, 2, 1, fp);
fwrite(tt, 1, ((d86f_get_sides(drive) == 2) ? 2048 : 1024), f);
fwrite(tt, 1, ((d86f_get_sides(drive) == 2) ? 2048 : 1024), fp);
/* In the case of a thick track drive, always increment track
by two, since two tracks are going to get output at once. */
@@ -3455,17 +3461,17 @@ d86f_export(int drive, char *fn)
else
fdd_do_seek(drive, i);
dev->cur_track = i;
d86f_write_tracks(drive, &f, tt);
d86f_write_tracks(drive, &fp, tt);
}
fclose(f);
fclose(fp);
f = plat_fopen(fn, "rb+");
fp = plat_fopen(fn, "rb+");
fseek(f, 8, SEEK_SET);
fwrite(tt, 1, ((d86f_get_sides(drive) == 2) ? 2048 : 1024), f);
fseek(fp, 8, SEEK_SET);
fwrite(tt, 1, ((d86f_get_sides(drive) == 2) ? 2048 : 1024), fp);
fclose(f);
fclose(fp);
fdd_do_seek(drive, fdd_current_track(drive));
@@ -3492,10 +3498,10 @@ d86f_load(int drive, char *fn)
writeprot[drive] = 0;
dev->f = plat_fopen(fn, "rb+");
if (!dev->f) {
dev->f = plat_fopen(fn, "rb");
if (!dev->f) {
dev->fp = plat_fopen(fn, "rb+");
if (!dev->fp) {
dev->fp = plat_fopen(fn, "rb");
if (!dev->fp) {
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
free(dev);
return;
@@ -3508,16 +3514,16 @@ d86f_load(int drive, char *fn)
}
fwriteprot[drive] = writeprot[drive];
fseek(dev->f, 0, SEEK_END);
len = ftell(dev->f);
fseek(dev->f, 0, SEEK_SET);
fseek(dev->fp, 0, SEEK_END);
len = ftell(dev->fp);
fseek(dev->fp, 0, SEEK_SET);
(void) !fread(&magic, 4, 1, dev->f);
(void) !fread(&magic, 4, 1, dev->fp);
if (len < 16) {
/* File is WAY too small, abort. */
fclose(dev->f);
dev->f = NULL;
fclose(dev->fp);
dev->fp = NULL;
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
free(dev);
return;
@@ -3526,13 +3532,13 @@ d86f_load(int drive, char *fn)
if ((magic != 0x46423638) && (magic != 0x66623638)) {
/* File is not of the valid format, abort. */
d86f_log("86F: Unrecognized magic bytes: %08X\n", magic);
fclose(dev->f);
fclose(dev->fp);
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
free(dev);
return;
}
if (fread(&(dev->version), 1, 2, dev->f) != 2)
if (fread(&(dev->version), 1, 2, dev->fp) != 2)
fatal("d86f_load(): Error reading format version\n");
if (dev->version != D86FVER) {
@@ -3544,8 +3550,8 @@ d86f_load(int drive, char *fn)
} else {
d86f_log("86F: Unrecognized file version: %i.%02i\n", dev->version >> 8, dev->version & 0xff);
}
fclose(dev->f);
dev->f = NULL;
fclose(dev->fp);
dev->fp = NULL;
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
free(dev);
return;
@@ -3553,7 +3559,7 @@ d86f_load(int drive, char *fn)
d86f_log("86F: Recognized file version: %i.%02i\n", dev->version >> 8, dev->version & 0xff);
}
(void) !fread(&(dev->disk_flags), 2, 1, dev->f);
(void) !fread(&(dev->disk_flags), 2, 1, dev->fp);
if (d86f_has_surface_desc(drive)) {
for (uint8_t i = 0; i < 2; i++)
@@ -3572,31 +3578,31 @@ d86f_load(int drive, char *fn)
if (len < 51052) {
#endif
/* File too small, abort. */
fclose(dev->f);
dev->f = NULL;
fclose(dev->fp);
dev->fp = NULL;
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
free(dev);
return;
}
#ifdef DO_CRC64
fseek(dev->f, 8, SEEK_SET);
fread(&read_crc64, 1, 8, dev->f);
fseek(dev->fp, 8, SEEK_SET);
fread(&read_crc64, 1, 8, dev->fp);
fseek(dev->f, 0, SEEK_SET);
fseek(dev->fp, 0, SEEK_SET);
crc64 = 0xffffffffffffffff;
dev->filebuf = malloc(len);
fread(dev->filebuf, 1, len, dev->f);
fread(dev->filebuf, 1, len, dev->fp);
*(uint64_t *) &(dev->filebuf[8]) = 0xffffffffffffffff;
crc64 = (uint64_t) crc64speed(0, dev->filebuf, len);
free(dev->filebuf);
if (crc64 != read_crc64) {
d86f_log("86F: CRC64 error\n");
fclose(dev->f);
dev->f = NULL;
fclose(dev->fp);
dev->fp = NULL;
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
free(dev);
return;
@@ -3608,11 +3614,11 @@ d86f_load(int drive, char *fn)
memcpy(temp_file_name, drive ? nvr_path("TEMP$$$1.$$$") : nvr_path("TEMP$$$0.$$$"), 256);
memcpy(dev->original_file_name, fn, strlen(fn) + 1);
fclose(dev->f);
dev->f = NULL;
fclose(dev->fp);
dev->fp = NULL;
dev->f = plat_fopen(temp_file_name, "wb");
if (!dev->f) {
dev->fp = plat_fopen(temp_file_name, "wb");
if (!dev->fp) {
d86f_log("86F: Unable to create temporary decompressed file\n");
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
free(dev);
@@ -3621,9 +3627,9 @@ d86f_load(int drive, char *fn)
tf = plat_fopen(fn, "rb");
for (i = 0; i < 8; i++) {
for (uint8_t i = 0; i < 8; i++) {
fread(&temp, 1, 2, tf);
fwrite(&temp, 1, 2, dev->f);
fwrite(&temp, 1, 2, dev->fp);
}
dev->filebuf = (uint8_t *) malloc(len);
@@ -3631,14 +3637,14 @@ d86f_load(int drive, char *fn)
fread(dev->filebuf, 1, len, tf);
temp = lzf_decompress(dev->filebuf, len, dev->outbuf, 67108864);
if (temp) {
fwrite(dev->outbuf, 1, temp, dev->f);
fwrite(dev->outbuf, 1, temp, dev->fp);
}
free(dev->outbuf);
free(dev->filebuf);
fclose(tf);
fclose(dev->f);
dev->f = NULL;
fclose(dev->fp);
dev->fp = NULL;
if (!temp) {
d86f_log("86F: Error decompressing file\n");
@@ -3648,15 +3654,15 @@ d86f_load(int drive, char *fn)
return;
}
dev->f = plat_fopen(temp_file_name, "rb+");
dev->fp = plat_fopen(temp_file_name, "rb+");
}
#endif
if (dev->disk_flags & 0x100) {
/* Zoned disk. */
d86f_log("86F: Disk is zoned (Apple or Sony)\n");
fclose(dev->f);
dev->f = NULL;
fclose(dev->fp);
dev->fp = NULL;
#ifdef D86F_COMPRESS
if (dev->is_compressed)
plat_remove(temp_file_name);
@@ -3669,8 +3675,8 @@ d86f_load(int drive, char *fn)
if (dev->disk_flags & 0x600) {
/* Zone type is not 0 but the disk is fixed-RPM. */
d86f_log("86F: Disk is fixed-RPM but zone type is not 0\n");
fclose(dev->f);
dev->f = NULL;
fclose(dev->fp);
dev->fp = NULL;
#ifdef D86F_COMPRESS
if (dev->is_compressed)
plat_remove(temp_file_name);
@@ -3686,29 +3692,29 @@ d86f_load(int drive, char *fn)
}
if (writeprot[drive]) {
fclose(dev->f);
dev->f = NULL;
fclose(dev->fp);
dev->fp = NULL;
#ifdef D86F_COMPRESS
if (dev->is_compressed)
dev->f = plat_fopen(temp_file_name, "rb");
dev->fp = plat_fopen(temp_file_name, "rb");
else
#endif
dev->f = plat_fopen(fn, "rb");
dev->fp = plat_fopen(fn, "rb");
}
/* OK, set the drive data, other code needs it. */
d86f[drive] = dev;
fseek(dev->f, 8, SEEK_SET);
fseek(dev->fp, 8, SEEK_SET);
(void) !fread(dev->track_offset, 1, d86f_get_track_table_size(drive), dev->f);
(void) !fread(dev->track_offset, 1, d86f_get_track_table_size(drive), dev->fp);
if (!(dev->track_offset[0])) {
/* File has no track 0 side 0, abort. */
d86f_log("86F: No Track 0 side 0\n");
fclose(dev->f);
dev->f = NULL;
fclose(dev->fp);
dev->fp = NULL;
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
free(dev);
d86f[drive] = NULL;
@@ -3718,8 +3724,8 @@ d86f_load(int drive, char *fn)
if ((d86f_get_sides(drive) == 2) && !(dev->track_offset[1])) {
/* File is 2-sided but has no track 0 side 1, abort. */
d86f_log("86F: No Track 0 side 1\n");
fclose(dev->f);
dev->f = NULL;
fclose(dev->fp);
dev->fp = NULL;
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
free(dev);
d86f[drive] = NULL;
@@ -3727,12 +3733,12 @@ d86f_load(int drive, char *fn)
}
/* Load track 0 flags as default. */
if (fseek(dev->f, dev->track_offset[0], SEEK_SET) == -1)
if (fseek(dev->fp, dev->track_offset[0], SEEK_SET) == -1)
fatal("d86f_load(): Track 0: Error seeking to the beginning of the file\n");
if (fread(&(dev->side_flags[0]), 1, 2, dev->f) != 2)
if (fread(&(dev->side_flags[0]), 1, 2, dev->fp) != 2)
fatal("d86f_load(): Track 0: Error reading side flags\n");
if (dev->disk_flags & 0x80) {
if (fread(&(dev->extra_bit_cells[0]), 1, 4, dev->f) != 4)
if (fread(&(dev->extra_bit_cells[0]), 1, 4, dev->fp) != 4)
fatal("d86f_load(): Track 0: Error reading the amount of extra bit cells\n");
if ((dev->disk_flags & 0x1060) != 0x1000) {
if (dev->extra_bit_cells[0] < -32768)
@@ -3745,12 +3751,12 @@ d86f_load(int drive, char *fn)
}
if (d86f_get_sides(drive) == 2) {
if (fseek(dev->f, dev->track_offset[1], SEEK_SET) == -1)
if (fseek(dev->fp, dev->track_offset[1], SEEK_SET) == -1)
fatal("d86f_load(): Track 1: Error seeking to the beginning of the file\n");
if (fread(&(dev->side_flags[1]), 1, 2, dev->f) != 2)
if (fread(&(dev->side_flags[1]), 1, 2, dev->fp) != 2)
fatal("d86f_load(): Track 1: Error reading side flags\n");
if (dev->disk_flags & 0x80) {
if (fread(&(dev->extra_bit_cells[1]), 1, 4, dev->f) != 4)
if (fread(&(dev->extra_bit_cells[1]), 1, 4, dev->fp) != 4)
fatal("d86f_load(): Track 4: Error reading the amount of extra bit cells\n");
if ((dev->disk_flags & 0x1060) != 0x1000) {
if (dev->extra_bit_cells[1] < -32768)
@@ -3781,10 +3787,10 @@ d86f_load(int drive, char *fn)
dev->extra_bit_cells[1] = 0;
}
fseek(dev->f, 0, SEEK_END);
dev->file_size = ftell(dev->f);
fseek(dev->fp, 0, SEEK_END);
dev->file_size = ftell(dev->fp);
fseek(dev->f, 0, SEEK_SET);
fseek(dev->fp, 0, SEEK_SET);
d86f_register_86f(drive);
@@ -3847,9 +3853,9 @@ d86f_close(int drive)
}
}
if (dev->f) {
fclose(dev->f);
dev->f = NULL;
if (dev->fp) {
fclose(dev->fp);
dev->fp = NULL;
}
#ifdef D86F_COMPRESS
if (dev->is_compressed)

36
src/floppy/fdd_fdi.c
View File

@@ -36,8 +36,8 @@
#include <86box/fdc.h>
#include <fdi2raw.h>
typedef struct {
FILE *f;
typedef struct fdi_t {
FILE *fp;
FDI *h;
int lasttrack;
@@ -176,10 +176,10 @@ fdi_density(void)
static int32_t
extra_bit_cells(int drive, int side)
{
fdi_t *dev = fdi[drive];
int density = 0;
int raw_size = 0;
int is_300_rpm = 0;
const fdi_t *dev = fdi[drive];
int density = 0;
int raw_size = 0;
int is_300_rpm = 0;
density = fdi_density();
@@ -249,8 +249,8 @@ read_revolution(int drive)
static uint32_t
index_hole_pos(int drive, int side)
{
fdi_t *dev = fdi[drive];
int density;
const fdi_t *dev = fdi[drive];
int density;
density = fdi_density();
@@ -260,8 +260,8 @@ index_hole_pos(int drive, int side)
static uint32_t
get_raw_size(int drive, int side)
{
fdi_t *dev = fdi[drive];
int density;
const fdi_t *dev = fdi[drive];
int density;
density = fdi_density();
@@ -291,7 +291,7 @@ fdi_seek(int drive, int track)
d86f_set_cur_track(drive, track);
if (dev->f == NULL)
if (dev->fp == NULL)
return;
if (track < 0)
@@ -327,16 +327,16 @@ fdi_load(int drive, char *fn)
d86f_unregister(drive);
dev->f = plat_fopen(fn, "rb");
if (fread(header, 1, 25, dev->f) != 25)
dev->fp = plat_fopen(fn, "rb");
if (fread(header, 1, 25, dev->fp) != 25)
fatal("fdi_load(): Error reading header\n");
if (fseek(dev->f, 0, SEEK_SET) == -1)
if (fseek(dev->fp, 0, SEEK_SET) == -1)
fatal("fdi_load(): Error seeking to the beginning of the file\n");
header[25] = 0;
if (strcmp(header, "Formatted Disk Image file") != 0) {
/* This is a Japanese FDI file. */
fdi_log("fdi_load(): Japanese FDI file detected, redirecting to IMG loader\n");
fclose(dev->f);
fclose(dev->fp);
free(dev);
img_load(drive, fn);
return;
@@ -345,7 +345,7 @@ fdi_load(int drive, char *fn)
/* Set up the drive unit. */
fdi[drive] = dev;
dev->h = fdi2raw_header(dev->f);
dev->h = fdi2raw_header(dev->fp);
dev->lasttrack = fdi2raw_get_last_track(dev->h);
dev->sides = fdi2raw_get_last_head(dev->h) + 1;
@@ -386,8 +386,8 @@ fdi_close(int drive)
if (dev->h)
fdi2raw_header_free(dev->h);
if (dev->f)
fclose(dev->f);
if (dev->fp)
fclose(dev->fp);
/* Release the memory. */
free(dev);

266
src/floppy/fdd_imd.c
View File

@@ -31,7 +31,7 @@
#include <86box/fdd_imd.h>
#include <86box/fdc.h>
typedef struct {
typedef struct imd_track_t {
uint8_t is_present;
uint32_t file_offs;
uint8_t params[5];
@@ -47,8 +47,8 @@ typedef struct {
uint8_t max_sector_size;
} imd_track_t;
typedef struct {
FILE *f;
typedef struct imd_t {
FILE *fp;
char *buffer;
uint32_t start_offs;
int track_count;
@@ -136,21 +136,20 @@ get_raw_tsize(int side_flags, int slower_rpm)
static int
track_is_xdf(int drive, int side, int track)
{
imd_t *dev = imd[drive];
int i;
int effective_sectors;
int xdf_sectors;
int high_sectors;
int low_sectors;
int max_high_id;
int expected_high_count;
int expected_low_count;
uint8_t *r_map;
uint8_t *n_map;
imd_t *dev = imd[drive];
int effective_sectors;
int xdf_sectors;
int high_sectors;
int low_sectors;
int max_high_id;
int expected_high_count;
int expected_low_count;
const uint8_t *r_map;
const uint8_t *n_map;
effective_sectors = xdf_sectors = high_sectors = low_sectors = 0;
for (i = 0; i < 256; i++)
for (uint16_t i = 0; i < 256; i++)
dev->xdf_ordered_pos[i][side] = 0;
if (dev->tracks[track][side].params[2] & 0xC0)
@@ -175,7 +174,7 @@ track_is_xdf(int drive, int side, int track)
expected_low_count = 0;
}
for (i = 0; i < dev->tracks[track][side].params[3]; i++) {
for (uint8_t i = 0; i < dev->tracks[track][side].params[3]; i++) {
if ((r_map[i] >= 0x81) && (r_map[i] <= max_high_id)) {
high_sectors++;
dev->xdf_ordered_pos[(int) r_map[i]][side] = i;
@@ -196,7 +195,7 @@ track_is_xdf(int drive, int side, int track)
n_map = (uint8_t *) (dev->buffer + dev->tracks[track][side].n_map_offs);
for (i = 0; i < dev->tracks[track][side].params[3]; i++) {
for (uint8_t i = 0; i < dev->tracks[track][side].params[3]; i++) {
effective_sectors++;
if (!(r_map[i]) && !(n_map[i]))
effective_sectors--;
@@ -224,10 +223,10 @@ track_is_xdf(int drive, int side, int track)
static int
track_is_interleave(int drive, int side, int track)
{
imd_t *dev = imd[drive];
int effective_sectors;
char *r_map;
int track_spt;
imd_t *dev = imd[drive];
int effective_sectors;
const char *r_map;
int track_spt;
effective_sectors = 0;
@@ -263,9 +262,9 @@ track_is_interleave(int drive, int side, int track)
static void
sector_to_buffer(int drive, int track, int side, uint8_t *buffer, int sector, int len)
{
imd_t *dev = imd[drive];
int type = dev->buffer[dev->tracks[track][side].sector_data_offs[sector]];
uint8_t fill_char;
const imd_t *dev = imd[drive];
int type = dev->buffer[dev->tracks[track][side].sector_data_offs[sector]];
uint8_t fill_char;
if (type == 0)
memset(buffer, 0x00, len);
@@ -282,35 +281,35 @@ sector_to_buffer(int drive, int track, int side, uint8_t *buffer, int sector, in
static void
imd_seek(int drive, int track)
{
uint32_t track_buf_pos[2] = { 0, 0 };
uint8_t id[4] = { 0, 0, 0, 0 };
uint8_t type;
imd_t *dev = imd[drive];
int sector;
int current_pos;
int c = 0;
int h;
int n;
int ssize = 512;
int track_rate = 0;
int track_gap2 = 22;
int track_gap3 = 12;
int xdf_type = 0;
int interleave_type = 0;
int is_trackx = 0;
int xdf_spt = 0;
int xdf_sector = 0;
int ordered_pos = 0;
int real_sector = 0;
int actual_sector = 0;
char *c_map = NULL;
char *h_map = NULL;
char *r_map;
char *n_map = NULL;
uint8_t *data;
int flags = 0x00;
uint32_t track_buf_pos[2] = { 0, 0 };
uint8_t id[4] = { 0, 0, 0, 0 };
uint8_t type;
imd_t *dev = imd[drive];
int sector;
int current_pos;
int c = 0;
int h;
int n;
int ssize = 512;
int track_rate = 0;
int track_gap2 = 22;
int track_gap3 = 12;
int xdf_type = 0;
int interleave_type = 0;
int is_trackx = 0;
int xdf_spt = 0;
int xdf_sector = 0;
int ordered_pos = 0;
int real_sector = 0;
int actual_sector = 0;
const char *c_map = NULL;
const char *h_map = NULL;
const char *r_map;
const char *n_map = NULL;
uint8_t *data;
int flags = 0x00;
if (dev->f == NULL)
if (dev->fp == NULL)
return;
if (!dev->track_width && fdd_doublestep_40(drive))
@@ -452,7 +451,7 @@ imd_seek(int drive, int track)
static uint16_t
disk_flags(int drive)
{
imd_t *dev = imd[drive];
const imd_t *dev = imd[drive];
return (dev->disk_flags);
}
@@ -460,9 +459,9 @@ disk_flags(int drive)
static uint16_t
side_flags(int drive)
{
imd_t *dev = imd[drive];
int side = 0;
uint16_t sflags = 0;
const imd_t *dev = imd[drive];
int side = 0;
uint16_t sflags = 0;
side = fdd_get_head(drive);
sflags = dev->current_side_flags[side];
@@ -473,19 +472,19 @@ side_flags(int drive)
static void
set_sector(int drive, int side, uint8_t c, uint8_t h, uint8_t r, uint8_t n)
{
imd_t *dev = imd[drive];
int track = dev->track;
int sc;
int sh;
int sn;
char *c_map = NULL;
char *h_map = NULL;
char *r_map = NULL;
char *n_map = NULL;
uint8_t id[4] = { 0, 0, 0, 0 };
sc = dev->tracks[track][side].params[1];
sh = dev->tracks[track][side].params[2];
sn = dev->tracks[track][side].params[4];
imd_t *dev = imd[drive];
int track = dev->track;
int sc;
int sh;
int sn;
const char *c_map = NULL;
const char *h_map = NULL;
const char *r_map = NULL;
const char *n_map = NULL;
uint8_t id[4] = { 0, 0, 0, 0 };
sc = dev->tracks[track][side].params[1];
sh = dev->tracks[track][side].params[2];
sn = dev->tracks[track][side].params[4];
if (sh & 0x80)
c_map = dev->buffer + dev->tracks[track][side].c_map_offs;
@@ -513,39 +512,39 @@ set_sector(int drive, int side, uint8_t c, uint8_t h, uint8_t r, uint8_t n)
static void
imd_writeback(int drive)
{
imd_t *dev = imd[drive];
int track = dev->track;
char *n_map = 0;
uint8_t h;
uint8_t n;
uint8_t spt;
uint32_t ssize;
imd_t *dev = imd[drive];
int track = dev->track;
const char *n_map = 0;
uint8_t h;
uint8_t n;
uint8_t spt;
uint32_t ssize;
if (writeprot[drive])
return;
for (int side = 0; side < dev->sides; side++) {
if (dev->tracks[track][side].is_present) {
fseek(dev->f, dev->tracks[track][side].file_offs, SEEK_SET);
fseek(dev->fp, dev->tracks[track][side].file_offs, SEEK_SET);
h = dev->tracks[track][side].params[2];
spt = dev->tracks[track][side].params[3];
n = dev->tracks[track][side].params[4];
fwrite(dev->tracks[track][side].params, 1, 5, dev->f);
fwrite(dev->tracks[track][side].params, 1, 5, dev->fp);
if (h & 0x80)
fwrite(dev->buffer + dev->tracks[track][side].c_map_offs, 1, spt, dev->f);
fwrite(dev->buffer + dev->tracks[track][side].c_map_offs, 1, spt, dev->fp);
if (h & 0x40)
fwrite(dev->buffer + dev->tracks[track][side].h_map_offs, 1, spt, dev->f);
fwrite(dev->buffer + dev->tracks[track][side].h_map_offs, 1, spt, dev->fp);
if (n == 0xFF) {
n_map = dev->buffer + dev->tracks[track][side].n_map_offs;
fwrite(n_map, 1, spt, dev->f);
fwrite(n_map, 1, spt, dev->fp);
}
for (uint8_t i = 0; i < spt; i++) {
ssize = (n == 0xFF) ? n_map[i] : n;
ssize = 128 << ssize;
fwrite(dev->buffer + dev->tracks[track][side].sector_data_offs[i], 1, ssize, dev->f);
fwrite(dev->buffer + dev->tracks[track][side].sector_data_offs[i], 1, ssize, dev->fp);
}
}
}
@@ -554,8 +553,8 @@ imd_writeback(int drive)
static uint8_t
poll_read_data(int drive, int side, uint16_t pos)
{
imd_t *dev = imd[drive];
int type = dev->current_data[side][0];
const imd_t *dev = imd[drive];
int type = dev->current_data[side][0];
if ((type == 0) || (type > 8))
return 0xf6; /* Should never happen. */
@@ -569,8 +568,8 @@ poll_read_data(int drive, int side, uint16_t pos)
static void
poll_write_data(int drive, int side, uint16_t pos, uint8_t data)
{
imd_t *dev = imd[drive];
int type = dev->current_data[side][0];
const imd_t *dev = imd[drive];
int type = dev->current_data[side][0];
if (writeprot[drive])
return;
@@ -584,10 +583,10 @@ poll_write_data(int drive, int side, uint16_t pos, uint8_t data)
static int
format_conditions(int drive)
{
imd_t *dev = imd[drive];
int track = dev->track;
int side;
int temp;
const imd_t *dev = imd[drive];
int track = dev->track;
int side;
int temp;
side = fdd_get_head(drive);
temp = (fdc_get_format_sectors(imd_fdc) == dev->tracks[track][side].params[3]);
@@ -605,29 +604,28 @@ imd_init(void)
void
imd_load(int drive, char *fn)
{
uint32_t magic = 0;
uint32_t fsize = 0;
char *buffer;
char *buffer2;
imd_t *dev;
int i = 0;
int track_spt = 0;
int sector_size = 0;
int track = 0;
int side = 0;
int extra = 0;
uint32_t last_offset = 0;
uint32_t data_size = 512;
uint32_t mfm = 0;
uint32_t pre_sector = 0;
uint32_t track_total = 0;
uint32_t raw_tsize = 0;
uint32_t minimum_gap3 = 0;
uint32_t minimum_gap4 = 0;
uint8_t converted_rate;
uint8_t type;
int size_diff;
int gap_sum;
uint32_t magic = 0;
uint32_t fsize = 0;
const char *buffer;
const char *buffer2;
imd_t *dev;
int track_spt = 0;
int sector_size = 0;
int track = 0;
int side = 0;
int extra = 0;
uint32_t last_offset = 0;
uint32_t data_size = 512;
uint32_t mfm = 0;
uint32_t pre_sector = 0;
uint32_t track_total = 0;
uint32_t raw_tsize = 0;
uint32_t minimum_gap3 = 0;
uint32_t minimum_gap4 = 0;
uint8_t converted_rate;
uint8_t type;
int size_diff;
int gap_sum;
d86f_unregister(drive);
@@ -637,10 +635,10 @@ imd_load(int drive, char *fn)
dev = (imd_t *) malloc(sizeof(imd_t));
memset(dev, 0x00, sizeof(imd_t));
dev->f = plat_fopen(fn, "rb+");
if (dev->f == NULL) {
dev->f = plat_fopen(fn, "rb");
if (dev->f == NULL) {
dev->fp = plat_fopen(fn, "rb+");
if (dev->fp == NULL) {
dev->fp = plat_fopen(fn, "rb");
if (dev->fp == NULL) {
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
free(dev);
return;
@@ -652,40 +650,40 @@ imd_load(int drive, char *fn)
writeprot[drive] = 1;
fwriteprot[drive] = writeprot[drive];
if (fseek(dev->f, 0, SEEK_SET) == -1)
if (fseek(dev->fp, 0, SEEK_SET) == -1)
fatal("imd_load(): Error seeking to the beginning of the file\n");
if (fread(&magic, 1, 4, dev->f) != 4)
if (fread(&magic, 1, 4, dev->fp) != 4)
fatal("imd_load(): Error reading the magic number\n");
if (magic != 0x20444D49) {
imd_log("IMD: Not a valid ImageDisk image\n");
fclose(dev->f);
fclose(dev->fp);
free(dev);
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
return;
} else
imd_log("IMD: Valid ImageDisk image\n");
if (fseek(dev->f, 0, SEEK_END) == -1)
if (fseek(dev->fp, 0, SEEK_END) == -1)
fatal("imd_load(): Error seeking to the end of the file\n");
fsize = ftell(dev->f);
fsize = ftell(dev->fp);
if (fsize <= 0) {
imd_log("IMD: Too small ImageDisk image\n");
fclose(dev->f);
fclose(dev->fp);
free(dev);
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
return;
}
if (fseek(dev->f, 0, SEEK_SET) == -1)
if (fseek(dev->fp, 0, SEEK_SET) == -1)
fatal("imd_load(): Error seeking to the beginning of the file again\n");
dev->buffer = malloc(fsize);
if (fread(dev->buffer, 1, fsize, dev->f) != fsize)
if (fread(dev->buffer, 1, fsize, dev->fp) != fsize)
fatal("imd_load(): Error reading data\n");
buffer = dev->buffer;
buffer2 = memchr(buffer, 0x1A, fsize);
if (buffer2 == NULL) {
imd_log("IMD: No ASCII EOF character\n");
fclose(dev->f);
fclose(dev->fp);
free(dev);
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
return;
@@ -696,7 +694,7 @@ imd_load(int drive, char *fn)
buffer2++;
if ((buffer2 - buffer) == fsize) {
imd_log("IMD: File ends after ASCII EOF character\n");
fclose(dev->f);
fclose(dev->fp);
free(dev);
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
return;
@@ -775,7 +773,7 @@ imd_load(int drive, char *fn)
dev->tracks[track][side].data_offs = last_offset;
for (i = 0; i < track_spt; i++) {
for (int i = 0; i < track_spt; i++) {
data_size = buffer2[i];
data_size = 128 << data_size;
dev->tracks[track][side].sector_data_offs[i] = last_offset;
@@ -784,7 +782,7 @@ imd_load(int drive, char *fn)
/* Invalid sector data type, possibly a malformed HxC IMG image (it outputs data errored
sectors with a variable amount of bytes, against the specification). */
imd_log("IMD: Invalid sector data type %02X\n", dev->buffer[dev->tracks[track][side].sector_data_offs[i]]);
fclose(dev->f);
fclose(dev->fp);
free(dev);
imd[drive] = NULL;
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
@@ -807,7 +805,7 @@ imd_load(int drive, char *fn)
} else {
dev->tracks[track][side].data_offs = last_offset;
for (i = 0; i < track_spt; i++) {
for (int i = 0; i < track_spt; i++) {
data_size = sector_size;
data_size = 128 << data_size;
dev->tracks[track][side].sector_data_offs[i] = last_offset;
@@ -816,7 +814,7 @@ imd_load(int drive, char *fn)
/* Invalid sector data type, possibly a malformed HxC IMG image (it outputs data errored
sectors with a variable amount of bytes, against the specification). */
imd_log("IMD: Invalid sector data type %02X\n", dev->buffer[dev->tracks[track][side].sector_data_offs[i]]);
fclose(dev->f);
fclose(dev->fp);
free(dev);
imd[drive] = NULL;
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
@@ -865,7 +863,7 @@ imd_load(int drive, char *fn)
if (size_diff < gap_sum) {
/* If we can't fit the sectors with a reasonable minimum gap even at 2% slower RPM, abort. */
imd_log("IMD: Unable to fit the %i sectors in a track\n", track_spt);
fclose(dev->f);
fclose(dev->fp);
free(dev);
imd[drive] = NULL;
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
@@ -931,10 +929,10 @@ imd_close(int drive)
d86f_unregister(drive);
if (dev->f != NULL) {
if (dev->fp != NULL) {
free(dev->buffer);
fclose(dev->f);
fclose(dev->fp);
}
/* Release the memory. */

224
src/floppy/fdd_img.c
View File

@@ -40,8 +40,8 @@
#include <86box/fdd_img.h>
#include <86box/fdc.h>
typedef struct {
FILE *f;
typedef struct img_t {
FILE *fp;
uint8_t track_data[2][688128];
int sectors, tracks, sides;
uint8_t sector_size;
@@ -418,17 +418,17 @@ write_back(int drive)
int ssize = 128 << ((int) dev->sector_size);
int size;
if (dev->f == NULL)
if (dev->fp == NULL)
return;
if (dev->disk_at_once)
return;
if (fseek(dev->f, dev->base + (dev->track * dev->sectors * ssize * dev->sides), SEEK_SET) == -1)
if (fseek(dev->fp, dev->base + (dev->track * dev->sectors * ssize * dev->sides), SEEK_SET) == -1)
pclog("IMG write_back(): Error seeking to the beginning of the file\n");
for (int side = 0; side < dev->sides; side++) {
size = dev->sectors * ssize;
if (fwrite(dev->track_data[side], 1, size, dev->f) != size)
if (fwrite(dev->track_data[side], 1, size, dev->fp) != size)
fatal("IMG write_back(): Error writing data\n");
}
}
@@ -436,7 +436,7 @@ write_back(int drive)
static uint16_t
disk_flags(int drive)
{
img_t *dev = img[drive];
const img_t *dev = img[drive];
return (dev->disk_flags);
}
@@ -444,7 +444,7 @@ disk_flags(int drive)
static uint16_t
side_flags(int drive)
{
img_t *dev = img[drive];
const img_t *dev = img[drive];
return (dev->track_flags);
}
@@ -461,7 +461,7 @@ set_sector(int drive, UNUSED(int side), UNUSED(uint8_t c), uint8_t h, uint8_t r,
static uint8_t
poll_read_data(int drive, UNUSED(int side), uint16_t pos)
{
img_t *dev = img[drive];
const img_t *dev = img[drive];
return (dev->track_data[dev->current_sector_pos_side][dev->current_sector_pos + pos]);
}
@@ -477,8 +477,8 @@ poll_write_data(int drive, UNUSED(int side), uint16_t pos, uint8_t data)
static int
format_conditions(int drive)
{
img_t *dev = img[drive];
int temp = (fdc_get_format_sectors(img_fdc) == dev->sectors);
const img_t *dev = img[drive];
int temp = (fdc_get_format_sectors(img_fdc) == dev->sectors);
temp = temp && (fdc_get_format_n(img_fdc) == dev->sector_size);
temp = temp && (dev->xdf_type == 0);
@@ -507,7 +507,7 @@ img_seek(int drive, int track)
int ssize = 128 << ((int) dev->sector_size);
uint32_t cur_pos = 0;
if (dev->f == NULL)
if (dev->fp == NULL)
return;
if (!dev->track_width && fdd_doublestep_40(drive))
@@ -519,7 +519,7 @@ img_seek(int drive, int track)
is_t0 = (track == 0) ? 1 : 0;
if (!dev->disk_at_once) {
if (fseek(dev->f, dev->base + (track * dev->sectors * ssize * dev->sides), SEEK_SET) == -1)
if (fseek(dev->fp, dev->base + (track * dev->sectors * ssize * dev->sides), SEEK_SET) == -1)
fatal("img_seek(): Error seeking\n");
}
@@ -528,7 +528,7 @@ img_seek(int drive, int track)
cur_pos = (track * dev->sectors * ssize * dev->sides) + (side * dev->sectors * ssize);
memcpy(dev->track_data[side], dev->disk_data + cur_pos, (size_t) dev->sectors * ssize);
} else {
read_bytes = fread(dev->track_data[side], 1, (size_t) dev->sectors * ssize, dev->f);
read_bytes = fread(dev->track_data[side], 1, (size_t) dev->sectors * ssize, dev->fp);
if (read_bytes < (dev->sectors * ssize))
memset(dev->track_data[side] + read_bytes, 0xf6, (dev->sectors * ssize) - read_bytes);
}
@@ -682,10 +682,10 @@ img_load(int drive, char *fn)
dev = (img_t *) malloc(sizeof(img_t));
memset(dev, 0x00, sizeof(img_t));
dev->f = plat_fopen(fn, "rb+");
if (dev->f == NULL) {
dev->f = plat_fopen(fn, "rb");
if (dev->f == NULL) {
dev->fp = plat_fopen(fn, "rb+");
if (dev->fp == NULL) {
dev->fp = plat_fopen(fn, "rb");
if (dev->fp == NULL) {
free(dev);
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
return;
@@ -710,23 +710,23 @@ img_load(int drive, char *fn)
if (!strcasecmp(ext, "FDI")) {
/* This is a Japanese FDI image, so let's read the header */
img_log("img_load(): File is a Japanese FDI image...\n");
fseek(dev->f, 0x10, SEEK_SET);
(void) !fread(&bpb_bps, 1, 2, dev->f);
fseek(dev->f, 0x0C, SEEK_SET);
(void) !fread(&size, 1, 4, dev->f);
fseek(dev->fp, 0x10, SEEK_SET);
(void) !fread(&bpb_bps, 1, 2, dev->fp);
fseek(dev->fp, 0x0C, SEEK_SET);
(void) !fread(&size, 1, 4, dev->fp);
bpb_total = size / bpb_bps;
fseek(dev->f, 0x08, SEEK_SET);
(void) !fread(&(dev->base), 1, 4, dev->f);
fseek(dev->f, dev->base + 0x15, SEEK_SET);
bpb_mid = fgetc(dev->f);
fseek(dev->fp, 0x08, SEEK_SET);
(void) !fread(&(dev->base), 1, 4, dev->fp);
fseek(dev->fp, dev->base + 0x15, SEEK_SET);
bpb_mid = fgetc(dev->fp);
if (bpb_mid < 0xF0)
bpb_mid = 0xF0;
fseek(dev->f, 0x14, SEEK_SET);
bpb_sectors = fgetc(dev->f);
fseek(dev->f, 0x18, SEEK_SET);
bpb_sides = fgetc(dev->f);
fseek(dev->f, dev->base, SEEK_SET);
first_byte = fgetc(dev->f);
fseek(dev->fp, 0x14, SEEK_SET);
bpb_sectors = fgetc(dev->fp);
fseek(dev->fp, 0x18, SEEK_SET);
bpb_sides = fgetc(dev->fp);
fseek(dev->fp, dev->base, SEEK_SET);
first_byte = fgetc(dev->fp);
fdi = 1;
cqm = 0;
@@ -734,53 +734,53 @@ img_load(int drive, char *fn)
fdf = 0;
} else {
/* Read the first four bytes. */
fseek(dev->f, 0x00, SEEK_SET);
first_byte = fgetc(dev->f);
fseek(dev->f, 0x01, SEEK_SET);
second_byte = fgetc(dev->f);
fseek(dev->f, 0x02, SEEK_SET);
third_byte = fgetc(dev->f);
fseek(dev->f, 0x03, SEEK_SET);
fourth_byte = fgetc(dev->f);
fseek(dev->fp, 0x00, SEEK_SET);
first_byte = fgetc(dev->fp);
fseek(dev->fp, 0x01, SEEK_SET);
second_byte = fgetc(dev->fp);
fseek(dev->fp, 0x02, SEEK_SET);
third_byte = fgetc(dev->fp);
fseek(dev->fp, 0x03, SEEK_SET);
fourth_byte = fgetc(dev->fp);
if ((first_byte == 0x1A) && (second_byte == 'F') && (third_byte == 'D') && (fourth_byte == 'F')) {
/* This is a FDF image. */
img_log("img_load(): File is a FDF image...\n");
fwriteprot[drive] = writeprot[drive] = 1;
fclose(dev->f);
dev->f = plat_fopen(fn, "rb");
fclose(dev->fp);
dev->fp = plat_fopen(fn, "rb");
fdf = 1;
cqm = 0;
dev->disk_at_once = 1;
fseek(dev->f, 0x50, SEEK_SET);
(void) !fread(&dev->tracks, 1, 4, dev->f);
fseek(dev->fp, 0x50, SEEK_SET);
(void) !fread(&dev->tracks, 1, 4, dev->fp);
/* Decode the entire file - pass 1, no write to buffer, determine length. */
fseek(dev->f, 0x80, SEEK_SET);
fseek(dev->fp, 0x80, SEEK_SET);
size = 0;
track_bytes = 0;
bpos = dev->disk_data;
while (!feof(dev->f)) {
while (!feof(dev->fp)) {
if (!track_bytes) {
/* Skip first 3 bytes - their meaning is unknown to us but could be a checksum. */
first_byte = fgetc(dev->f);
(void) !fread(&track_bytes, 1, 2, dev->f);
first_byte = fgetc(dev->fp);
(void) !fread(&track_bytes, 1, 2, dev->fp);
img_log("Block header: %02X %04X ", first_byte, track_bytes);
/* Read the length of encoded data block. */
(void) !fread(&track_bytes, 1, 2, dev->f);
(void) !fread(&track_bytes, 1, 2, dev->fp);
img_log("%04X\n", track_bytes);
}
if (feof(dev->f))
if (feof(dev->fp))
break;
if (first_byte == 0xFF)
break;
if (first_byte) {
run = fgetc(dev->f);
run = fgetc(dev->fp);
/* I *HAVE* to read something because fseek tries to be smart and never hits EOF, causing an infinite loop. */
track_bytes--;
@@ -788,12 +788,12 @@ img_load(int drive, char *fn)
if (run & 0x80) {
/* Repeat. */
track_bytes--;
rep_byte = fgetc(dev->f);
rep_byte = fgetc(dev->fp);
} else {
/* Literal. */
track_bytes -= (run & 0x7f);
literal = (uint8_t *) malloc(run & 0x7f);
(void) !fread(literal, 1, (run & 0x7f), dev->f);
(void) !fread(literal, 1, (run & 0x7f), dev->fp);
free(literal);
}
size += (run & 0x7f);
@@ -803,12 +803,12 @@ img_load(int drive, char *fn)
/* Literal block. */
size += (track_bytes - fdf_suppress_final_byte);
literal = (uint8_t *) malloc(track_bytes);
(void) !fread(literal, 1, track_bytes, dev->f);
(void) !fread(literal, 1, track_bytes, dev->fp);
free(literal);
track_bytes = 0;
}
if (feof(dev->f))
if (feof(dev->fp))
break;
}
@@ -816,28 +816,28 @@ img_load(int drive, char *fn)
dev->disk_data = (uint8_t *) malloc(size);
/* Decode the entire file - pass 2, write to buffer. */
fseek(dev->f, 0x80, SEEK_SET);
fseek(dev->fp, 0x80, SEEK_SET);
track_bytes = 0;
bpos = dev->disk_data;
while (!feof(dev->f)) {
while (!feof(dev->fp)) {
if (!track_bytes) {
/* Skip first 3 bytes - their meaning is unknown to us but could be a checksum. */
first_byte = fgetc(dev->f);
(void) !fread(&track_bytes, 1, 2, dev->f);
first_byte = fgetc(dev->fp);
(void) !fread(&track_bytes, 1, 2, dev->fp);
img_log("Block header: %02X %04X ", first_byte, track_bytes);
/* Read the length of encoded data block. */
(void) !fread(&track_bytes, 1, 2, dev->f);
(void) !fread(&track_bytes, 1, 2, dev->fp);
img_log("%04X\n", track_bytes);
}
if (feof(dev->f))
if (feof(dev->fp))
break;
if (first_byte == 0xFF)
break;
if (first_byte) {
run = fgetc(dev->f);
run = fgetc(dev->fp);
real_run = (run & 0x7f);
/* I *HAVE* to read something because fseek tries to be smart and never hits EOF, causing an infinite loop. */
@@ -848,14 +848,14 @@ img_load(int drive, char *fn)
track_bytes--;
if (!track_bytes)
real_run -= fdf_suppress_final_byte;
rep_byte = fgetc(dev->f);
rep_byte = fgetc(dev->fp);
if (real_run)
memset(bpos, rep_byte, real_run);
} else {
/* Literal. */
track_bytes -= real_run;
literal = (uint8_t *) malloc(real_run);
(void) !fread(literal, 1, real_run, dev->f);
(void) !fread(literal, 1, real_run, dev->fp);
if (!track_bytes)
real_run -= fdf_suppress_final_byte;
if (run & 0x7f)
@@ -866,14 +866,14 @@ img_load(int drive, char *fn)
} else {
/* Literal block. */
literal = (uint8_t *) malloc(track_bytes);
(void) !fread(literal, 1, track_bytes, dev->f);
(void) !fread(literal, 1, track_bytes, dev->fp);
memcpy(bpos, literal, track_bytes - fdf_suppress_final_byte);
free(literal);
bpos += (track_bytes - fdf_suppress_final_byte);
track_bytes = 0;
}
if (feof(dev->f))
if (feof(dev->fp))
break;
}
@@ -892,48 +892,48 @@ img_load(int drive, char *fn)
if (((first_byte == 'C') && (second_byte == 'Q')) || ((first_byte == 'c') && (second_byte == 'q'))) {
img_log("img_load(): File is a CopyQM image...\n");
fwriteprot[drive] = writeprot[drive] = 1;
fclose(dev->f);
dev->f = plat_fopen(fn, "rb");
fclose(dev->fp);
dev->fp = plat_fopen(fn, "rb");
fseek(dev->f, 0x03, SEEK_SET);
(void) !fread(&bpb_bps, 1, 2, dev->f);
fseek(dev->fp, 0x03, SEEK_SET);
(void) !fread(&bpb_bps, 1, 2, dev->fp);
#if 0
fseek(dev->f, 0x0B, SEEK_SET);
(void) !fread(&bpb_total, 1, 2, dev->f);
fseek(dev->fp, 0x0B, SEEK_SET);
(void) !fread(&bpb_total, 1, 2, dev->fp);
#endif
fseek(dev->f, 0x10, SEEK_SET);
bpb_sectors = fgetc(dev->f);
fseek(dev->f, 0x12, SEEK_SET);
bpb_sides = fgetc(dev->f);
fseek(dev->f, 0x5B, SEEK_SET);
dev->tracks = fgetc(dev->f);
fseek(dev->fp, 0x10, SEEK_SET);
bpb_sectors = fgetc(dev->fp);
fseek(dev->fp, 0x12, SEEK_SET);
bpb_sides = fgetc(dev->fp);
fseek(dev->fp, 0x5B, SEEK_SET);
dev->tracks = fgetc(dev->fp);
bpb_total = ((uint16_t) bpb_sectors) * ((uint16_t) bpb_sides) * dev->tracks;
fseek(dev->f, 0x74, SEEK_SET);
dev->interleave = fgetc(dev->f);
fseek(dev->f, 0x76, SEEK_SET);
dev->skew = fgetc(dev->f);
fseek(dev->fp, 0x74, SEEK_SET);
dev->interleave = fgetc(dev->fp);
fseek(dev->fp, 0x76, SEEK_SET);
dev->skew = fgetc(dev->fp);
dev->disk_data = (uint8_t *) malloc(((uint32_t) bpb_total) * ((uint32_t) bpb_bps));
memset(dev->disk_data, 0xf6, ((uint32_t) bpb_total) * ((uint32_t) bpb_bps));
fseek(dev->f, 0x6F, SEEK_SET);
(void) !fread(&comment_len, 1, 2, dev->f);
fseek(dev->fp, 0x6F, SEEK_SET);
(void) !fread(&comment_len, 1, 2, dev->fp);
fseek(dev->f, -1, SEEK_END);
size = ftell(dev->f) + 1;
fseek(dev->fp, -1, SEEK_END);
size = ftell(dev->fp) + 1;
fseek(dev->f, 133 + comment_len, SEEK_SET);
fseek(dev->fp, 133 + comment_len, SEEK_SET);
cur_pos = 0;
while (!feof(dev->f)) {
(void) !fread(&block_len, 1, 2, dev->f);
while (!feof(dev->fp)) {
(void) !fread(&block_len, 1, 2, dev->fp);
if (!feof(dev->f)) {
if (!feof(dev->fp)) {
if (block_len < 0) {
rep_byte = fgetc(dev->f);
rep_byte = fgetc(dev->fp);
block_len = -block_len;
if ((cur_pos + block_len) > ((uint32_t) bpb_total) * ((uint32_t) bpb_bps)) {
block_len = ((uint32_t) bpb_total) * ((uint32_t) bpb_bps) - cur_pos;
@@ -946,10 +946,10 @@ img_load(int drive, char *fn)
} else if (block_len > 0) {
if ((cur_pos + block_len) > ((uint32_t) bpb_total) * ((uint32_t) bpb_bps)) {
block_len = ((uint32_t) bpb_total) * ((uint32_t) bpb_bps) - cur_pos;
(void) !fread(dev->disk_data + cur_pos, 1, block_len, dev->f);
(void) !fread(dev->disk_data + cur_pos, 1, block_len, dev->fp);
break;
} else {
(void) !fread(dev->disk_data + cur_pos, 1, block_len, dev->f);
(void) !fread(dev->disk_data + cur_pos, 1, block_len, dev->fp);
cur_pos += block_len;
}
}
@@ -969,22 +969,22 @@ img_load(int drive, char *fn)
fwriteprot[drive] = writeprot[drive] = 1;
} else
img_log("img_load(): File is a raw image...\n");
fseek(dev->f, dev->base + 0x0B, SEEK_SET);
(void) !fread(&bpb_bps, 1, 2, dev->f);
fseek(dev->f, dev->base + 0x13, SEEK_SET);
(void) !fread(&bpb_total, 1, 2, dev->f);
fseek(dev->f, dev->base + 0x15, SEEK_SET);
bpb_mid = fgetc(dev->f);
fseek(dev->f, dev->base + 0x18, SEEK_SET);
bpb_sectors = fgetc(dev->f);
fseek(dev->f, dev->base + 0x1A, SEEK_SET);
bpb_sides = fgetc(dev->f);
fseek(dev->fp, dev->base + 0x0B, SEEK_SET);
(void) !fread(&bpb_bps, 1, 2, dev->fp);
fseek(dev->fp, dev->base + 0x13, SEEK_SET);
(void) !fread(&bpb_total, 1, 2, dev->fp);
fseek(dev->fp, dev->base + 0x15, SEEK_SET);
bpb_mid = fgetc(dev->fp);
fseek(dev->fp, dev->base + 0x18, SEEK_SET);
bpb_sectors = fgetc(dev->fp);
fseek(dev->fp, dev->base + 0x1A, SEEK_SET);
bpb_sides = fgetc(dev->fp);
cqm = 0;
}
fseek(dev->f, -1, SEEK_END);
size = ftell(dev->f) + 1;
fseek(dev->fp, -1, SEEK_END);
size = ftell(dev->fp) + 1;
if (ddi)
size -= 0x2400;
@@ -1125,7 +1125,7 @@ jump_if_fdf:
dev->tracks = 86;
} else {
img_log("Image is bigger than can fit on an ED floppy, ejecting...\n");
fclose(dev->f);
fclose(dev->fp);
free(dev);
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
return;
@@ -1138,9 +1138,9 @@ jump_if_fdf:
/* The BPB readings appear to be valid, so let's set the values. */
if (fdi) {
/* The image is a Japanese FDI, therefore we read the number of tracks from the header. */
if (fseek(dev->f, 0x1C, SEEK_SET) == -1)
if (fseek(dev->fp, 0x1C, SEEK_SET) == -1)
fatal("Japanese FDI: Failed when seeking to 0x1C\n");
(void) !fread(&(dev->tracks), 1, 4, dev->f);
(void) !fread(&(dev->tracks), 1, 4, dev->fp);
} else {
if (!cqm && !fdf) {
/* Number of tracks = number of total sectors divided by sides times sectors per track. */
@@ -1182,7 +1182,7 @@ jump_if_fdf:
if (temp_rate == 0xFF) {
img_log("Image is bigger than can fit on an ED floppy, ejecting...\n");
fclose(dev->f);
fclose(dev->fp);
free(dev);
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
return;
@@ -1199,7 +1199,7 @@ jump_if_fdf:
}
if (!dev->gap3_size) {
img_log("ERROR: Floppy image of unknown format was inserted into drive %c:!\n", drive + 0x41);
fclose(dev->f);
fclose(dev->fp);
free(dev);
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
return;
@@ -1259,9 +1259,9 @@ img_close(int drive)
d86f_unregister(drive);
if (dev->f != NULL) {
fclose(dev->f);
dev->f = NULL;
if (dev->fp != NULL) {
fclose(dev->fp);
dev->fp = NULL;
}
if (dev->disk_data != NULL)

51
src/floppy/fdd_json.c
View File

@@ -62,7 +62,7 @@
#define NSIDES 2
#define NSECTORS 256
typedef struct {
typedef struct sector_t {
uint8_t track; /* ID: track number */
uint8_t side; /* side number */
uint8_t sector; /* sector number 1.. */
@@ -70,8 +70,8 @@ typedef struct {
uint8_t *data; /* allocated data for it */
} sector_t;
typedef struct {
FILE *f;
typedef struct json_t {
FILE *fp;
/* Geometry. */
uint8_t tracks; /* number of tracks */
@@ -215,7 +215,7 @@ load_image(json_t *dev)
int level;
char *ptr;
if (dev->f == NULL) {
if (dev->fp == NULL) {
json_log("JSON: no file loaded!\n");
return 0;
}
@@ -232,8 +232,8 @@ load_image(json_t *dev)
level = state = 0;
while (state >= 0) {
/* Get a character from the input. */
c = fgetc(dev->f);
if ((c == EOF) || ferror(dev->f)) {
c = fgetc(dev->fp);
if ((c == EOF) || ferror(dev->fp)) {
state = -1;
break;
}
@@ -372,6 +372,9 @@ load_image(json_t *dev)
}
dev->track++;
break;
default:
break;
}
}
@@ -396,7 +399,7 @@ json_seek(int drive, int track)
int rsec;
int asec;
if (dev->f == NULL) {
if (dev->fp == NULL) {
json_log("JSON: seek: no file loaded!\n");
return;
}
@@ -464,7 +467,7 @@ json_seek(int drive, int track)
static uint16_t
disk_flags(int drive)
{
json_t *dev = images[drive];
const json_t *dev = images[drive];
return (dev->disk_flags);
}
@@ -472,7 +475,7 @@ disk_flags(int drive)
static uint16_t
track_flags(int drive)
{
json_t *dev = images[drive];
const json_t *dev = images[drive];
return (dev->track_flags);
}
@@ -502,8 +505,8 @@ set_sector(int drive, int side, uint8_t c, uint8_t h, uint8_t r, uint8_t n)
static uint8_t
poll_read_data(int drive, int side, uint16_t pos)
{
json_t *dev = images[drive];
uint8_t sec = dev->sector[side];
const json_t *dev = images[drive];
uint8_t sec = dev->sector[side];
return (dev->sects[dev->track][side][sec].data[pos]);
}
@@ -517,10 +520,10 @@ json_init(void)
void
json_load(int drive, char *fn)
{
double bit_rate;
int temp_rate;
sector_t *sec;
json_t *dev;
double bit_rate;
int temp_rate;
const sector_t *sec;
json_t *dev;
/* Just in case- remove ourselves from 86F. */
d86f_unregister(drive);
@@ -530,8 +533,8 @@ json_load(int drive, char *fn)
memset(dev, 0x00, sizeof(json_t));
/* Open the image file. */
dev->f = plat_fopen(fn, "rb");
if (dev->f == NULL) {
dev->fp = plat_fopen(fn, "rb");
if (dev->fp == NULL) {
free(dev);
memset(fn, 0x00, sizeof(char));
return;
@@ -546,7 +549,7 @@ json_load(int drive, char *fn)
/* Load all sectors from the image file. */
if (!load_image(dev)) {
json_log("JSON: failed to initialize\n");
(void) fclose(dev->f);
(void) fclose(dev->fp);
free(dev);
images[drive] = NULL;
memset(fn, 0x00, sizeof(char));
@@ -608,8 +611,8 @@ json_load(int drive, char *fn)
if (temp_rate == 0xff) {
json_log("JSON: invalid image (temp_rate=0xff)\n");
(void) fclose(dev->f);
dev->f = NULL;
(void) fclose(dev->fp);
dev->fp = NULL;
free(dev);
images[drive] = NULL;
memset(fn, 0x00, sizeof(char));
@@ -630,8 +633,8 @@ json_load(int drive, char *fn)
if (!dev->gap3_len) {
json_log("JSON: image of unknown format was inserted into drive %c:!\n",
'C' + drive);
(void) fclose(dev->f);
dev->f = NULL;
(void) fclose(dev->fp);
dev->fp = NULL;
free(dev);
images[drive] = NULL;
memset(fn, 0x00, sizeof(char));
@@ -692,8 +695,8 @@ json_close(int drive)
}
}
if (dev->f != NULL)
(void) fclose(dev->f);
if (dev->fp != NULL)
(void) fclose(dev->fp);
/* Release the memory. */
free(dev);

62
src/floppy/fdd_mfm.c
View File

@@ -32,7 +32,7 @@
#include <86box/fdc.h>
#pragma pack(push, 1)
typedef struct {
typedef struct mfm_header_t {
uint8_t hdr_name[7];
uint16_t tracks_no;
@@ -45,14 +45,14 @@ typedef struct {
uint32_t track_list_offset;
} mfm_header_t;
typedef struct {
typedef struct mfm_track_t {
uint16_t track_no;
uint8_t side_no;
uint32_t track_size;
uint32_t track_offset;
} mfm_track_t;
typedef struct {
typedef struct mfm_adv_track_t {
uint16_t track_no;
uint8_t side_no;
uint16_t rpm;
@@ -62,8 +62,8 @@ typedef struct {
} mfm_adv_track_t;
#pragma pack(pop)
typedef struct {
FILE *f;
typedef struct mfm_t {
FILE *fp;
mfm_header_t hdr;
mfm_track_t *tracks;
@@ -105,8 +105,8 @@ mfm_log(const char *fmt, ...)
static int
get_track_index(int drive, int side, int track)
{
mfm_t *dev = mfm[drive];
int ret = -1;
const mfm_t *dev = mfm[drive];
int ret = -1;
for (int i = 0; i < dev->total_tracks; i++) {
if ((dev->tracks[i].track_no == track) && (dev->tracks[i].side_no == side)) {
@@ -121,8 +121,8 @@ get_track_index(int drive, int side, int track)
static int
get_adv_track_index(int drive, int side, int track)
{
mfm_t *dev = mfm[drive];
int ret = -1;
const mfm_t *dev = mfm[drive];
int ret = -1;
for (int i = 0; i < dev->total_tracks; i++) {
if ((dev->adv_tracks[i].track_no == track) && (dev->adv_tracks[i].side_no == side)) {
@@ -137,9 +137,9 @@ get_adv_track_index(int drive, int side, int track)
static void
get_adv_track_bitrate(int drive, int side, int track, int *br, int *rpm)
{
mfm_t *dev = mfm[drive];
int track_index;
double dbr;
const mfm_t *dev = mfm[drive];
int track_index;
double dbr;
track_index = get_adv_track_index(drive, side, track);
@@ -197,7 +197,7 @@ set_disk_flags(int drive)
static uint16_t
disk_flags(int drive)
{
mfm_t *dev = mfm[drive];
const mfm_t *dev = mfm[drive];
return dev->disk_flags;
}
@@ -257,8 +257,8 @@ set_side_flags(int drive, int side)
static uint16_t
side_flags(int drive)
{
mfm_t *dev = mfm[drive];
int side;
const mfm_t *dev = mfm[drive];
int side;
side = fdd_get_head(drive);
@@ -268,11 +268,11 @@ side_flags(int drive)
static uint32_t
get_raw_size(int drive, int side)
{
mfm_t *dev = mfm[drive];
int track_index;
int is_300_rpm;
int br = 250;
int rpm = 300;
const mfm_t *dev = mfm[drive];
int track_index;
int is_300_rpm;
int br = 250;
int rpm = 300;
if (dev->hdr.if_type & 0x80) {
track_index = get_adv_track_index(drive, side, dev->cur_track);
@@ -345,12 +345,12 @@ mfm_read_side(int drive, int side)
memset(dev->track_data[side], 0x00, track_bytes);
else {
if (dev->hdr.if_type & 0x80)
ret = fseek(dev->f, dev->adv_tracks[track_index].track_offset, SEEK_SET);
ret = fseek(dev->fp, dev->adv_tracks[track_index].track_offset, SEEK_SET);
else
ret = fseek(dev->f, dev->tracks[track_index].track_offset, SEEK_SET);
ret = fseek(dev->fp, dev->tracks[track_index].track_offset, SEEK_SET);
if (ret == -1)
fatal("mfm_read_side(): Error seeking to the beginning of the file\n");
if (fread(dev->track_data[side], 1, track_bytes, dev->f) != track_bytes)
if (fread(dev->track_data[side], 1, track_bytes, dev->fp) != track_bytes)
fatal("mfm_read_side(): Error reading track bytes\n");
}
@@ -373,7 +373,7 @@ mfm_seek(int drive, int track)
dev->cur_track = track;
d86f_set_cur_track(drive, track);
if (dev->f == NULL)
if (dev->fp == NULL)
return;
if (track < 0)
@@ -399,8 +399,8 @@ mfm_load(int drive, char *fn)
dev = (mfm_t *) malloc(sizeof(mfm_t));
memset(dev, 0x00, sizeof(mfm_t));
dev->f = plat_fopen(fn, "rb");
if (dev->f == NULL) {
dev->fp = plat_fopen(fn, "rb");
if (dev->fp == NULL) {
free(dev);
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
return;
@@ -410,7 +410,7 @@ mfm_load(int drive, char *fn)
/* Read the header. */
size = sizeof(mfm_header_t);
if (fread(&dev->hdr, 1, size, dev->f) != size)
if (fread(&dev->hdr, 1, size, dev->fp) != size)
fatal("mfm_load(): Error reading header\n");
/* Calculate tracks * sides, allocate the tracks array, and read it. */
@@ -418,12 +418,12 @@ mfm_load(int drive, char *fn)
if (dev->hdr.if_type & 0x80) {
dev->adv_tracks = (mfm_adv_track_t *) malloc(dev->total_tracks * sizeof(mfm_adv_track_t));
size = dev->total_tracks * sizeof(mfm_adv_track_t);
if (fread(dev->adv_tracks, 1, size, dev->f) != size)
if (fread(dev->adv_tracks, 1, size, dev->fp) != size)
fatal("mfm_load(): Error reading advanced tracks\n");
} else {
dev->tracks = (mfm_track_t *) malloc(dev->total_tracks * sizeof(mfm_track_t));
size = dev->total_tracks * sizeof(mfm_track_t);
if (fread(dev->tracks, 1, size, dev->f) != size)
if (fread(dev->tracks, 1, size, dev->fp) != size)
fatal("mfm_load(): Error reading tracks\n");
}
@@ -504,8 +504,8 @@ mfm_close(int drive)
if (dev->adv_tracks)
free(dev->adv_tracks);
if (dev->f)
fclose(dev->f);
if (dev->fp)
fclose(dev->fp);
/* Release the memory. */
free(dev);

119
src/floppy/fdd_td0.c
View File

@@ -60,7 +60,7 @@
/* update when cumulative frequency */
/* reaches to this value */
typedef struct {
typedef struct tdlzhuf_t {
uint16_t r;
uint16_t bufcnt; /* string buffer */
uint16_t bufndx; /* string buffer */
@@ -72,7 +72,7 @@ typedef struct {
uint8_t inbuf[BUFSZ]; /* input buffer */
} tdlzhuf;
typedef struct {
typedef struct td0dsk_t {
FILE *fdd_file;
off_t fdd_file_offset;
@@ -93,7 +93,7 @@ typedef struct {
uint8_t getlen;
} td0dsk_t;
typedef struct {
typedef struct td0_sector_t {
uint8_t track;
uint8_t head;
uint8_t sector;
@@ -103,8 +103,8 @@ typedef struct {
uint8_t *data;
} td0_sector_t;
typedef struct {
FILE *f;
typedef struct td0_t {
FILE *fp;
int tracks;
int track_width;
@@ -227,9 +227,9 @@ fdd_image_read(int drive, char *buffer, uint32_t offset, uint32_t len)
{
td0_t *dev = td0[drive];
if (fseek(dev->f, offset, SEEK_SET) == -1)
if (fseek(dev->fp, offset, SEEK_SET) == -1)
fatal("fdd_image_read(): Error seeking to the beginning of the file\n");
if (fread(buffer, 1, len, dev->f) != len)
if (fread(buffer, 1, len, dev->fp) != len)
fatal("fdd_image_read(): Error reading data\n");
}
@@ -595,45 +595,45 @@ get_raw_tsize(int side_flags, int slower_rpm)
static int
td0_initialize(int drive)
{
td0_t *dev = td0[drive];
uint8_t header[12];
int fm;
int head;
int track;
int track_count = 0;
int head_count = 0;
int track_spt;
int track_spt_adjusted;
int offset = 0;
int density = 0;
int temp_rate = 0;
uint32_t file_size;
uint16_t len;
uint16_t rep;
td0dsk_t disk_decode;
uint8_t *hs;
uint16_t size;
uint8_t *dbuf = dev->processed_buf;
uint32_t total_size = 0;
uint32_t id_field = 0;
uint32_t pre_sector = 0;
int32_t track_size = 0;
int32_t raw_tsize = 0;
uint32_t minimum_gap3 = 0;
uint32_t minimum_gap4 = 0;
int i;
int j;
int k;
int size_diff;
int gap_sum;
td0_t *dev = td0[drive];
uint8_t header[12];
int fm;
int head;
int track;
int track_count = 0;
int head_count = 0;
int track_spt;
int track_spt_adjusted;
int offset = 0;
int density = 0;
int temp_rate = 0;
uint32_t file_size;
uint16_t len;
uint16_t rep;
td0dsk_t disk_decode;
const uint8_t *hs;
uint16_t size;
uint8_t *dbuf = dev->processed_buf;
uint32_t total_size = 0;
uint32_t id_field = 0;
uint32_t pre_sector = 0;
int32_t track_size = 0;
int32_t raw_tsize = 0;
uint32_t minimum_gap3 = 0;
uint32_t minimum_gap4 = 0;
int i;
int j;
int k;
int size_diff;
int gap_sum;
if (dev->f == NULL) {
if (dev->fp == NULL) {
td0_log("TD0: Attempted to initialize without loading a file first\n");
return 0;
}
fseek(dev->f, 0, SEEK_END);
file_size = ftell(dev->f);
fseek(dev->fp, 0, SEEK_END);
file_size = ftell(dev->fp);
if (file_size < 12) {
td0_log("TD0: File is too small to even contain the header\n");
@@ -645,21 +645,21 @@ td0_initialize(int drive)
return 0;
}
fseek(dev->f, 0, SEEK_SET);
(void) !fread(header, 1, 12, dev->f);
fseek(dev->fp, 0, SEEK_SET);
(void) !fread(header, 1, 12, dev->fp);
head_count = header[9];
if (header[0] == 't') {
td0_log("TD0: File is compressed\n");
disk_decode.fdd_file = dev->f;
disk_decode.fdd_file = dev->fp;
state_init_Decode(&disk_decode);
disk_decode.fdd_file_offset = 12;
state_Decode(&disk_decode, dev->imagebuf, TD0_MAX_BUFSZ);
} else {
td0_log("TD0: File is uncompressed\n");
if (fseek(dev->f, 12, SEEK_SET) == -1)
if (fseek(dev->fp, 12, SEEK_SET) == -1)
fatal("td0_initialize(): Error seeking to offet 12\n");
if (fread(dev->imagebuf, 1, file_size - 12, dev->f) != (file_size - 12))
if (fread(dev->imagebuf, 1, file_size - 12, dev->fp) != (file_size - 12))
fatal("td0_initialize(): Error reading image buffer\n");
}
@@ -710,6 +710,9 @@ td0_initialize(int drive)
dev->default_track_flags = (density == 1) ? 0x00 : ((density == 2) ? 0x03 : 0x02);
dev->max_sector_size = (density == 1) ? 6 : ((density == 2) ? 7 : 5); /* 16384, 8192, or 4096 bytes. */
break;
default:
break;
}
dev->disk_flags = header[5] & 0x06;
@@ -886,7 +889,7 @@ td0_initialize(int drive)
static uint16_t
disk_flags(int drive)
{
td0_t *dev = td0[drive];
const td0_t *dev = td0[drive];
return (dev->disk_flags);
}
@@ -894,9 +897,9 @@ disk_flags(int drive)
static uint16_t
side_flags(int drive)
{
td0_t *dev = td0[drive];
int side = 0;
uint16_t sflags = 0;
const td0_t *dev = td0[drive];
int side = 0;
uint16_t sflags = 0;
side = fdd_get_head(drive);
sflags = dev->current_side_flags[side];
@@ -923,7 +926,7 @@ set_sector(int drive, int side, uint8_t c, uint8_t h, uint8_t r, uint8_t n)
static uint8_t
poll_read_data(int drive, int side, uint16_t pos)
{
td0_t *dev = td0[drive];
const td0_t *dev = td0[drive];
return (dev->sects[dev->track][side][dev->current_sector_index[side]].data[pos]);
}
@@ -1064,7 +1067,7 @@ td0_seek(int drive, int track)
int fm;
int sector_adjusted;
if (dev->f == NULL)
if (dev->fp == NULL)
return;
if (!dev->track_width && fdd_doublestep_40(drive))
@@ -1182,8 +1185,8 @@ td0_abort(int drive)
free(dev->imagebuf);
if (dev->processed_buf)
free(dev->processed_buf);
if (dev->f)
fclose(dev->f);
if (dev->fp)
fclose(dev->fp);
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
free(dev);
td0[drive] = NULL;
@@ -1203,8 +1206,8 @@ td0_load(int drive, char *fn)
memset(dev, 0x00, sizeof(td0_t));
td0[drive] = dev;
dev->f = plat_fopen(fn, "rb");
if (dev->f == NULL) {
dev->fp = plat_fopen(fn, "rb");
if (dev->fp == NULL) {
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
return;
}
@@ -1285,8 +1288,8 @@ td0_close(int drive)
memset(dev->sects[i][j], 0, sizeof(td0_sector_t));
}
if (dev->f != NULL)
fclose(dev->f);
if (dev->fp != NULL)
fclose(dev->fp);
/* Release resources. */
free(dev);

111
src/floppy/fdi2raw.c
View File

@@ -36,7 +36,9 @@
#include <fdi2raw.h>
#include <86box/plat_unused.h>
#ifdef DEBUG
#undef DEBUG
#endif
#define VERBOSE
#undef VERBOSE
@@ -96,24 +98,24 @@ static int fdi_allocated;
#ifdef DEBUG
static void
fdi_free(void *p)
fdi_free(void *priv)
{
int size;
if (!p)
if (!priv)
return;
size = ((int *) p)[-1];
size = ((int *) priv)[-1];
fdi_allocated -= size;
write_log("%d freed (%d)\n", size, fdi_allocated);
free((int *) p - 1);
free((int *) priv - 1);
}
static void *
fdi_malloc(int size)
{
void *p = xmalloc(size + sizeof(int));
((int *) p)[0] = size;
void *priv = xmalloc(size + sizeof(int));
((int *) prv)[0] = size;
fdi_allocated += size;
write_log("%d allocated (%d)\n", size, fdi_allocated);
return (int *) p + 1;
return (int *) priv + 1;
}
#else
# define fdi_free free
@@ -1290,6 +1292,9 @@ track_atari_st(struct fdi *fdi, int max_sector)
case 10:
gap3 = 24;
break;
default:
break;
}
s15(fdi);
for (int i = 0; i < max_sector; i++) {
@@ -1915,9 +1920,9 @@ fdi2_decode(FDI *fdi, uint32_t totalavg, uint32_t *avgp, uint32_t *minp, uint32_
static void
fdi2_celltiming(FDI *fdi, uint32_t totalavg, int bitoffset, uint16_t *out)
{
uint16_t *pt2;
uint16_t *pt;
double avg_bit_len;
const uint16_t *pt2;
uint16_t *pt;
double avg_bit_len;
avg_bit_len = (double) totalavg / (double) bitoffset;
pt2 = fdi->track_dst_buffer_timing;
@@ -1935,27 +1940,27 @@ fdi2_celltiming(FDI *fdi, uint32_t totalavg, int bitoffset, uint16_t *out)
static int
decode_lowlevel_track(FDI *fdi, int track, struct fdi_cache *cache)
{
uint8_t *p1;
uint32_t *p2;
uint32_t *avgp;
uint32_t *minp = 0;
uint32_t *maxp = 0;
uint8_t *idxp = 0;
uint32_t maxidx;
uint32_t totalavg;
uint32_t weakbits;
int i;
int j;
int len;
int pulses;
int indexoffset;
int avg_free;
int min_free = 0;
int max_free = 0;
int idx_free;
int idx_off1 = 0;
int idx_off2 = 0;
int idx_off3 = 0;
uint8_t *p1;
const uint32_t *p2;
uint32_t *avgp;
uint32_t *minp = 0;
uint32_t *maxp = 0;
uint8_t *idxp = 0;
uint32_t maxidx;
uint32_t totalavg;
uint32_t weakbits;
int j;
int k;
int len;
int pulses;
int indexoffset;
int avg_free;
int min_free = 0;
int max_free = 0;
int idx_free;
int idx_off1 = 0;
int idx_off2 = 0;
int idx_off3 = 0;
p1 = fdi->track_src;
pulses = get_u32(p1);
@@ -1974,7 +1979,7 @@ decode_lowlevel_track(FDI *fdi, int track, struct fdi_cache *cache)
maxp = (uint32_t *) fdi_decompress(pulses, p1 + 6, p1 + len, &max_free);
len += get_u24(p1 + 6) & 0x3fffff;
/* Computes the real min and max values */
for (i = 0; i < pulses; i++) {
for (int i = 0; i < pulses; i++) {
maxp[i] = avgp[i] + minp[i] - maxp[i];
minp[i] = avgp[i] - minp[i];
}
@@ -2000,7 +2005,7 @@ decode_lowlevel_track(FDI *fdi, int track, struct fdi_cache *cache)
} else {
idxp = fdi_malloc(pulses * 2);
idx_free = 1;
for (i = 0; i < pulses; i++) {
for (int i = 0; i < pulses; i++) {
idxp[i * 2 + 0] = 2;
idxp[i * 2 + 1] = 0;
}
@@ -2011,43 +2016,43 @@ decode_lowlevel_track(FDI *fdi, int track, struct fdi_cache *cache)
maxidx = 0;
indexoffset = 0;
p1 = idxp;
for (i = 0; i < pulses; i++) {
for (int i = 0; i < pulses; i++) {
if ((uint32_t) p1[idx_off1] + (uint32_t) p1[idx_off2] > maxidx)
maxidx = p1[idx_off1] + p1[idx_off2];
p1 += idx_off3;
}
p1 = idxp;
for (i = 0; (i < pulses) && (p1[idx_off2] != 0); i++) /* falling edge, replace with idx_off1 for rising edge */
for (k = 0; (k < pulses) && (p1[idx_off2] != 0); k++) /* falling edge, replace with idx_off1 for rising edge */
p1 += idx_off3;
if (i < pulses) {
j = i;
if (k < pulses) {
j = k;
do {
i++;
k++;
p1 += idx_off3;
if (i >= pulses) {
i = 0;
if (k >= pulses) {
k = 0;
p1 = idxp;
}
} while ((i != j) && (p1[idx_off2] == 0)); /* falling edge, replace with idx_off1 for rising edge */
if (i != j) /* index pulse detected */
} while ((k != j) && (p1[idx_off2] == 0)); /* falling edge, replace with idx_off1 for rising edge */
if (k != j) /* index pulse detected */
{
while ((i != j) && (p1[idx_off1] > p1[idx_off2])) { /* falling edge, replace with "<" for rising edge */
i++;
while ((k != j) && (p1[idx_off1] > p1[idx_off2])) { /* falling edge, replace with "<" for rising edge */
k++;
p1 += idx_off3;
if (i >= pulses) {
i = 0;
if (k >= pulses) {
k = 0;
p1 = idxp;
}
}
if (i != j)
indexoffset = i; /* index position detected */
if (k != j)
indexoffset = k; /* index position detected */
}
}
p1 = idxp;
p2 = avgp;
totalavg = 0;
weakbits = 0;
for (i = 0; i < pulses; i++) {
for (int i = 0; i < pulses; i++) {
uint32_t sum = p1[idx_off1] + p1[idx_off2];
if (sum >= maxidx) {
totalavg += *p2;
@@ -2254,7 +2259,7 @@ fdi2raw_loadrevolution_2(FDI *fdi, uint16_t *mfmbuf, uint16_t *tracktiming, int
*tracklength = len;
for (int i = 0; i < (len + 15) / (2 * 8); i++) {
uint8_t *data = fdi->track_dst_buffer + i * 2;
const uint8_t *data = fdi->track_dst_buffer + i * 2;
*mfmbuf++ = 256 * *data + *(data + 1);
}
fdi2_celltiming(fdi, cache->totalavg, len, tracktiming);
@@ -2273,7 +2278,7 @@ fdi2raw_loadrevolution(FDI *fdi, uint16_t *mfmbuf, uint16_t *tracktiming, int tr
int
fdi2raw_loadtrack(FDI *fdi, uint16_t *mfmbuf, uint16_t *tracktiming, int track, int *tracklength, int *indexoffsetp, int *multirev, int mfm)
{
uint8_t *p;
const uint8_t *p;
int outlen;
struct fdi_cache *cache = &fdi->cache[track];
@@ -2347,8 +2352,8 @@ fdi2raw_loadtrack(FDI *fdi, uint16_t *mfmbuf, uint16_t *tracktiming, int track,
return fdi2raw_loadrevolution_2(fdi, mfmbuf, tracktiming, track, tracklength, indexoffsetp, multirev, mfm);
*tracklength = fdi->out;
for (int i = 0; i < ((*tracklength) + 15) / (2 * 8); i++) {
uint8_t *data = fdi->track_dst_buffer + i * 2;
*mfmbuf++ = 256 * *data + *(data + 1);
const uint8_t *data = fdi->track_dst_buffer + i * 2;
*mfmbuf++ = 256 * *data + *(data + 1);
}
}
return outlen;

Some files were not shown because too many files have changed in this diff Show More