claunia/86Box
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

More fixes for sonarcloud findings

Browse Source
This commit is contained in:
Jasmine Iwanek
2023-05-16 15:43:20 -04:00
parent ab733b7f6c
commit ce451a2bf4
25 changed files with 688 additions and 501 deletions
Download Patch File Download Diff File Expand all files Collapse all files

95
src/cdrom/cdrom.c
View File

@@ -183,12 +183,12 @@ cdrom_interface_has_config(int cdinterface)
const device_t *dev = cdrom_interface_get_device(cdinterface);
if (dev == NULL)
return (0);
return 0;
if (!device_has_config(dev))
return (0);
return 0;
return (1);
return 1;
}
int
@@ -257,7 +257,9 @@ int
cdrom_lba_to_msf_accurate(int lba)
{
int pos;
int m, s, f;
int m;
int s;
int f;
pos = lba + 150;
f = pos % 75;
@@ -401,7 +403,9 @@ cdrom_stop(cdrom_t *dev)
void
cdrom_seek(cdrom_t *dev, uint32_t pos, uint8_t vendor_type)
{
int m, s, f;
int m;
int s;
int f;
if (!dev)
return;
@@ -498,7 +502,9 @@ uint8_t
cdrom_audio_play(cdrom_t *dev, uint32_t pos, uint32_t len, int ismsf)
{
track_info_t ti;
int m = 0, s = 0, f = 0;
int m = 0;
int s = 0;
int f = 0;
if (dev->cd_status == CD_STATUS_DATA_ONLY)
return 0;
@@ -570,7 +576,9 @@ cdrom_audio_play(cdrom_t *dev, uint32_t pos, uint32_t len, int ismsf)
uint8_t
cdrom_audio_track_search(cdrom_t *dev, uint32_t pos, int type, uint8_t playbit)
{
int m = 0, s = 0, f = 0;
int m = 0;
int s = 0;
int f = 0;
if (dev->cd_status == CD_STATUS_DATA_ONLY)
return 0;
@@ -615,7 +623,9 @@ cdrom_audio_track_search(cdrom_t *dev, uint32_t pos, int type, uint8_t playbit)
uint8_t
cdrom_audio_play_toshiba(cdrom_t *dev, uint32_t pos, int type)
{
int m = 0, s = 0, f = 0;
int m = 0;
int s = 0;
int f = 0;
if (dev->cd_status == CD_STATUS_DATA_ONLY)
return 0;
@@ -657,7 +667,9 @@ cdrom_audio_play_toshiba(cdrom_t *dev, uint32_t pos, int type)
uint8_t
cdrom_audio_scan(cdrom_t *dev, uint32_t pos, int type)
{
int m = 0, s = 0, f = 0;
int m = 0;
int s = 0;
int f = 0;
if (dev->cd_status == CD_STATUS_DATA_ONLY)
return 0;
@@ -712,7 +724,10 @@ cdrom_get_current_subchannel(cdrom_t *dev, uint8_t *b, int msf)
{
uint8_t ret;
subchannel_t subc;
int pos = 1, m, s, f;
int pos = 1;
int m;
int s;
int f;
uint32_t dat;
dev->ops->get_subchannel(dev, dev->seek_pos, &subc);
@@ -895,9 +910,13 @@ static int
read_toc_normal(cdrom_t *dev, unsigned char *b, unsigned char start_track, int msf)
{
track_info_t ti;
int i, len = 4;
int m, s, f;
int first_track, last_track;
int i;
int len = 4;
int m;
int s;
int f;
int first_track;
int last_track;
uint32_t temp;
cdrom_log("read_toc_normal(%08X, %08X, %02X, %i)\n", dev, b, start_track, msf);
@@ -978,7 +997,10 @@ static int
read_toc_session(cdrom_t *dev, unsigned char *b, int msf)
{
track_info_t ti;
int len = 4, m, s, f;
int len = 4;
int m;
int s;
int f;
uint32_t temp;
cdrom_log("read_toc_session(%08X, %08X, %i)\n", dev, b, msf);
@@ -1027,8 +1049,9 @@ static int
read_toc_raw(cdrom_t *dev, unsigned char *b)
{
track_info_t ti;
int i, len = 4;
int first_track, last_track;
int len = 4;
int first_track;
int last_track;
cdrom_log("read_toc_raw(%08X, %08X)\n", dev, b);
@@ -1037,7 +1060,7 @@ read_toc_raw(cdrom_t *dev, unsigned char *b)
/* Bytes 2 and 3 = Number of first and last sessions */
b[2] = b[3] = 1;
for (i = 0; i <= last_track; i++) {
for (int i = 0; i <= last_track; i++) {
dev->ops->get_track_info(dev, i + 1, 0, &ti);
cdrom_log(" tracks(%i) = %02X, %02X, %i:%02i.%02i\n", i, ti.attr, ti.number, ti.m, ti.s, ti.f);
@@ -1061,8 +1084,10 @@ static int
read_toc_sony(cdrom_t *dev, unsigned char *b, unsigned char start_track, int msf)
{
track_info_t ti;
int i, len = 4;
int first_track, last_track;
int i;
int len = 4;
int first_track;
int last_track;
uint32_t temp;
cdrom_log("read_toc_sony(%08X, %08X, %02X, %i)\n", dev, b, start_track, msf);
@@ -1173,7 +1198,8 @@ void
cdrom_get_track_buffer(cdrom_t *dev, uint8_t *buf)
{
track_info_t ti;
int first_track, last_track;
int first_track;
int last_track;
if (dev != NULL) {
dev->ops->get_tracks(dev, &first_track, &last_track);
@@ -1196,7 +1222,8 @@ void
cdrom_get_q(cdrom_t *dev, uint8_t *buf, int *curtoctrk, uint8_t mode)
{
track_info_t ti;
int first_track, last_track;
int first_track;
int last_track;
if (dev != NULL) {
dev->ops->get_tracks(dev, &first_track, &last_track);
@@ -1254,8 +1281,11 @@ uint8_t
cdrom_read_disc_info_toc(cdrom_t *dev, unsigned char *b, unsigned char track, int type)
{
track_info_t ti;
int first_track, last_track;
int m = 0, s = 0, f = 0;
int first_track;
int last_track;
int m = 0;
int s = 0;
int f = 0;
dev->ops->get_tracks(dev, &first_track, &last_track);
@@ -1583,10 +1613,15 @@ int
cdrom_readsector_raw(cdrom_t *dev, uint8_t *buffer, int sector, int ismsf, int cdrom_sector_type,
int cdrom_sector_flags, int *len, uint8_t vendor_type)
{
uint8_t *b, *temp_b;
uint32_t msf, lba;
int audio = 0, mode2 = 0;
int m, s, f;
uint8_t *b;
uint8_t *temp_b;
uint32_t msf;
uint32_t lba;
int audio = 0;
int mode2 = 0;
int m;
int s;
int f;
if (dev->cd_status == CD_STATUS_EMPTY)
return 0;
@@ -1763,9 +1798,8 @@ void
cdrom_hard_reset(void)
{
cdrom_t *dev;
int i;
for (i = 0; i < CDROM_NUM; i++) {
for (uint8_t i = 0; i < CDROM_NUM; i++) {
dev = &cdrom[i];
if (dev->bus_type) {
cdrom_log("CD-ROM %i: Hard reset\n", i);
@@ -1798,9 +1832,8 @@ void
cdrom_close(void)
{
cdrom_t *dev;
int i;
for (i = 0; i < CDROM_NUM; i++) {
for (uint8_t i = 0; i < CDROM_NUM; i++) {
dev = &cdrom[i];
if (dev->bus_type == CDROM_BUS_SCSI)

20
src/cdrom/cdrom_image.c
View File

@@ -84,7 +84,8 @@ static void
image_get_subchannel(cdrom_t *dev, uint32_t lba, subchannel_t *subc)
{
cd_img_t *img = (cd_img_t *) dev->image;
TMSF rel_pos, abs_pos;
TMSF rel_pos;
TMSF abs_pos;
cdi_get_audio_sub(img, lba, &subc->attr, &subc->track, &subc->index,
&rel_pos, &abs_pos);
@@ -102,17 +103,19 @@ static int
image_get_capacity(cdrom_t *dev)
{
cd_img_t *img = (cd_img_t *) dev->image;
int first_track, last_track;
int number, c;
int first_track;
int last_track;
int number;
unsigned char attr;
uint32_t address = 0, lb = 0;
uint32_t address = 0;
uint32_t lb = 0;
if (!img)
return 0;
cdi_get_audio_tracks_lba(img, &first_track, &last_track, &lb);
for (c = 0; c <= last_track; c++) {
for (int c = 0; c <= last_track; c++) {
cdi_get_audio_track_info_lba(img, 0, c + 1, &number, &address, &attr);
if (address > lb)
lb = address;
@@ -127,8 +130,11 @@ image_is_track_audio(cdrom_t *dev, uint32_t pos, int ismsf)
cd_img_t *img = (cd_img_t *) dev->image;
uint8_t attr;
TMSF tmsf;
int m, s, f;
int number, track;
int m;
int s;
int f;
int number;
int track;
if (!img || (dev->cd_status == CD_STATUS_DATA_ONLY))
return 0;

78
src/cdrom/cdrom_image_backend.c
View File

@@ -202,14 +202,13 @@ track_file_close(track_t *trk)
static void
cdi_clear_tracks(cd_img_t *cdi)
{
int i;
track_file_t *last = NULL;
track_t *cur = NULL;
if ((cdi->tracks == NULL) || (cdi->tracks_num == 0))
return;
for (i = 0; i < cdi->tracks_num; i++) {
for (int i = 0; i < cdi->tracks_num; i++) {
cur = &cdi->tracks[i];
/* Make sure we do not attempt to close a NULL file. */
@@ -321,8 +320,8 @@ cdi_get_audio_track_info_lba(cd_img_t *cdi, int end, int track, int *track_num,
int
cdi_get_track(cd_img_t *cdi, uint32_t sector)
{
int i;
track_t *cur, *next;
track_t *cur;
track_t *next;
/* There must be at least two tracks - data and lead out. */
if (cdi->tracks_num < 2)
@@ -330,7 +329,7 @@ cdi_get_track(cd_img_t *cdi, uint32_t sector)
/* This has a problem - the code skips the last track, which is
lead out - is that correct? */
for (i = 0; i < (cdi->tracks_num - 1); i++) {
for (int i = 0; i < (cdi->tracks_num - 1); i++) {
cur = &cdi->tracks[i];
next = &cdi->tracks[i + 1];
if ((cur->start <= sector) && (sector < next->start))
@@ -368,12 +367,17 @@ cdi_read_sector(cd_img_t *cdi, uint8_t *buffer, int raw, uint32_t sector)
{
size_t length;
int track = cdi_get_track(cdi, sector) - 1;
uint64_t sect = (uint64_t) sector, seek;
uint64_t sect = (uint64_t) sector;
uint64_t seek;
track_t *trk;
int track_is_raw, ret;
int raw_size, cooked_size;
int track_is_raw;
int ret;
int raw_size;
int cooked_size;
uint64_t offset = 0ULL;
int m = 0, s = 0, f = 0;
int m = 0;
int s = 0;
int f = 0;
if (track < 0)
return 0;
@@ -428,9 +432,10 @@ cdi_read_sector(cd_img_t *cdi, uint8_t *buffer, int raw, uint32_t sector)
int
cdi_read_sectors(cd_img_t *cdi, uint8_t *buffer, int raw, uint32_t sector, uint32_t num)
{
int sector_size, success = 1;
int sector_size;
int success = 1;
uint8_t *buf;
uint32_t buf_len, i;
uint32_t buf_len;
/* TODO: This fails to account for Mode 2. Shouldn't we have a function
to get sector size? */
@@ -438,7 +443,7 @@ cdi_read_sectors(cd_img_t *cdi, uint8_t *buffer, int raw, uint32_t sector, uint3
buf_len = num * sector_size;
buf = (uint8_t *) malloc(buf_len * sizeof(uint8_t));
for (i = 0; i < num; i++) {
for (uint32_t i = 0; i < num; i++) {
success = cdi_read_sector(cdi, &buf[i * sector_size], raw, sector + i);
if (!success)
break;
@@ -461,7 +466,8 @@ cdi_read_sector_sub(cd_img_t *cdi, uint8_t *buffer, uint32_t sector)
{
int track = cdi_get_track(cdi, sector) - 1;
track_t *trk;
uint64_t s = (uint64_t) sector, seek;
uint64_t s = (uint64_t) sector;
uint64_t seek;
if (track < 0)
return 0;
@@ -550,7 +556,8 @@ cdi_track_push_back(cd_img_t *cdi, track_t *trk)
int
cdi_load_iso(cd_img_t *cdi, const char *filename)
{
int error, ret = 2;
int error;
int ret = 2;
track_t trk;
cdi->tracks = NULL;
@@ -698,7 +705,9 @@ static int
cdi_cue_get_frame(uint64_t *frames, char **line)
{
char temp[128];
int min, sec, fr;
int min;
int sec;
int fr;
int success;
success = cdi_cue_get_buffer(temp, line, 0);
@@ -717,7 +726,8 @@ cdi_cue_get_frame(uint64_t *frames, char **line)
static int
cdi_cue_get_flags(track_t *cur, char **line)
{
char temp[128], temp2[128];
char temp[128];
char temp2[128];
int success;
success = cdi_cue_get_buffer(temp, line, 0);
@@ -738,7 +748,8 @@ static int
cdi_add_track(cd_img_t *cdi, track_t *cur, uint64_t *shift, uint64_t prestart, uint64_t *total_pregap, uint64_t cur_pregap)
{
/* Frames between index 0 (prestart) and 1 (current track start) must be skipped. */
uint64_t skip, temp;
uint64_t skip;
uint64_t temp;
track_t *prev = NULL;
/* Skip *MUST* be calculated even if prestart is 0. */
@@ -805,16 +816,23 @@ int
cdi_load_cue(cd_img_t *cdi, const char *cuefile)
{
track_t trk;
char pathname[MAX_FILENAME_LENGTH], filename[MAX_FILENAME_LENGTH];
char pathname[MAX_FILENAME_LENGTH];
char filename[MAX_FILENAME_LENGTH];
char temp[MAX_FILENAME_LENGTH];
uint64_t shift = 0ULL, prestart = 0ULL;
uint64_t cur_pregap = 0ULL, total_pregap = 0ULL;
uint64_t frame = 0ULL, index;
int i, success;
int error, can_add_track = 0;
uint64_t shift = 0ULL;
uint64_t prestart = 0ULL;
uint64_t cur_pregap = 0ULL;
uint64_t total_pregap = 0ULL;
uint64_t frame = 0ULL;
uint64_t index;
int success;
int error;
int can_add_track = 0;
FILE *fp;
char buf[MAX_LINE_LENGTH], ansi[MAX_FILENAME_LENGTH];
char *line, *command;
char buf[MAX_LINE_LENGTH];
char ansi[MAX_FILENAME_LENGTH];
char *line;
char *command;
char *type;
cdi->tracks = NULL;
@@ -842,7 +860,7 @@ cdi_load_cue(cd_img_t *cdi, const char *cuefile)
/* Do two iterations to make sure to nuke even if it's \r\n or \n\r,
but do checks to make sure we're not nuking other bytes. */
for (i = 0; i < 2; i++) {
for (uint8_t i = 0; i < 2; i++) {
if (strlen(buf) > 0) {
if (buf[strlen(buf) - 1] == '\n')
buf[strlen(buf) - 1] = '\0';
@@ -1035,13 +1053,11 @@ cdi_load_cue(cd_img_t *cdi, const char *cuefile)
int
cdi_has_data_track(cd_img_t *cdi)
{
int i;
if ((cdi == NULL) || (cdi->tracks == NULL))
return 0;
/* Data track has attribute 0x14. */
for (i = 0; i < cdi->tracks_num; i++) {
for (int i = 0; i < cdi->tracks_num; i++) {
if (cdi->tracks[i].attr == DATA_TRACK)
return 1;
}
@@ -1052,13 +1068,11 @@ cdi_has_data_track(cd_img_t *cdi)
int
cdi_has_audio_track(cd_img_t *cdi)
{
int i;
if ((cdi == NULL) || (cdi->tracks == NULL))
return 0;
/* Audio track has attribute 0x14. */
for (i = 0; i < cdi->tracks_num; i++) {
for (int i = 0; i < cdi->tracks_num; i++) {
if (cdi->tracks[i].attr == AUDIO_TRACK)
return 1;
}

36
src/cdrom/cdrom_image_viso.c
View File

@@ -301,7 +301,8 @@ viso_fill_fn_short(char *data, const viso_entry_t *entry, viso_entry_t **entries
{
/* Get name and extension length. */
const char *ext_pos = strrchr(entry->basename, '.');
int name_len, ext_len;
int name_len;
int ext_len;
if (ext_pos) {
name_len = ext_pos - entry->basename;
ext_len = strlen(ext_pos);
@@ -472,7 +473,9 @@ viso_fill_time(uint8_t *data, time_t time, int format, int longform)
static int
viso_fill_dir_record(uint8_t *data, viso_entry_t *entry, viso_t *viso, int type)
{
uint8_t *p = data, *q, *r;
uint8_t *p = data;
uint8_t *q;
uint8_t *r;
*p++ = 0; /* size (filled in later) */
*p++ = 0; /* extended attribute length */
@@ -650,9 +653,9 @@ viso_read(void *p, uint8_t *buffer, uint64_t seek, size_t count)
/* Handle reads in a sector by sector basis. */
while (count > 0) {
/* Determine the current sector, offset and remainder. */
uint32_t sector = seek / viso->sector_size,
sector_offset = seek % viso->sector_size,
sector_remain = MIN(count, viso->sector_size - sector_offset);
uint32_t sector = seek / viso->sector_size;
uint32_t sector_offset = seek % viso->sector_size;
uint32_t sector_remain = MIN(count, viso->sector_size - sector_offset);
/* Handle sector. */
if (sector < viso->metadata_sectors) {
@@ -736,7 +739,8 @@ viso_close(void *p)
remove(nvr_path(viso->tf.fn));
#endif
viso_entry_t *entry = viso->root_dir, *next_entry;
viso_entry_t *entry = viso->root_dir;
viso_entry_t *next_entry;
while (entry) {
if (entry->file)
fclose(entry->file);
@@ -760,7 +764,8 @@ viso_init(const char *dirname, int *error)
/* Initialize our data structure. */
viso_t *viso = (viso_t *) calloc(1, sizeof(viso_t));
uint8_t *data = NULL, *p;
uint8_t *data = NULL;
uint8_t *p;
*error = 1;
if (viso == NULL)
goto end;
@@ -785,9 +790,15 @@ viso_init(const char *dirname, int *error)
/* Set up directory traversal. */
cdrom_image_viso_log("VISO: Traversing directories:\n");
viso_entry_t *entry, *last_entry, *dir, *last_dir, *eltorito_dir = NULL, *eltorito_entry = NULL;
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, eltorito_others_present = 0;
int len;
int eltorito_others_present = 0;
size_t dir_path_len;
uint64_t eltorito_offset = 0;
uint8_t eltorito_type = 0;
@@ -1445,8 +1456,8 @@ next_entry:
/* Go through files, assigning sectors to them. */
cdrom_image_viso_log("VISO: Assigning sectors to files:\n");
size_t base_factor = viso->sector_size / orig_sector_size;
viso_entry_t *prev_entry = viso->root_dir,
**entry_map_p = viso->entry_map;
viso_entry_t *prev_entry = viso->root_dir;
viso_entry_t **entry_map_p = viso->entry_map;
entry = prev_entry->next;
while (entry) {
/* Skip this entry if it corresponds to a directory. */
@@ -1512,7 +1523,8 @@ next_entry:
if (!viso->metadata)
goto end;
fseeko64(viso->tf.file, 0, SEEK_SET);
uint64_t metadata_size = viso->metadata_sectors * viso->sector_size, metadata_remain = metadata_size;
uint64_t metadata_size = viso->metadata_sectors * viso->sector_size;
uint64_t metadata_remain = metadata_size;
while (metadata_remain > 0)
metadata_remain -= fread(viso->metadata + (metadata_size - metadata_remain), 1, MIN(metadata_remain, viso->sector_size), viso->tf.file);

25
src/floppy/fdc.c
View File

@@ -146,7 +146,7 @@ fdc_card_available(int card)
if (fdc_cards[card].device)
return (device_available(fdc_cards[card].device));
return (1);
return 1;
}
const device_t *
@@ -159,7 +159,7 @@ int
fdc_card_has_config(int card)
{
if (!fdc_cards[card].device)
return (0);
return 0;
return (device_has_config(fdc_cards[card].device) ? 1 : 0);
}
@@ -177,11 +177,11 @@ fdc_card_get_from_internal_name(char *s)
while (fdc_cards[c].device != NULL) {
if (!strcmp((char *) fdc_cards[c].device->internal_name, s))
return (c);
return c;
c++;
}
return (0);
return 0;
}
void
@@ -710,7 +710,9 @@ fdc_write(uint16_t addr, uint8_t val, void *priv)
{
fdc_t *fdc = (fdc_t *) priv;
int drive, i, drive_num;
int drive;
int i;
int drive_num;
fdc_log("Write FDC %04X %02X\n", addr, val);
@@ -1630,7 +1632,7 @@ fdc_callback(void *priv)
fdc_poll_readwrite_finish(fdc, compare);
return;
}
if ((fdd_get_head(real_drive(fdc, fdc->drive)) == 0)) {
if (fdd_get_head(real_drive(fdc, fdc->drive)) == 0) {
fdc->sector = 1;
fdc->head |= 1;
fdd_set_head(real_drive(fdc, fdc->drive), 1);
@@ -1883,7 +1885,7 @@ fdc_is_verify(fdc_t *fdc)
int
fdc_data(fdc_t *fdc, uint8_t data, int last)
{
int i, result = 0;
int result = 0;
int n;
if (fdc->deleted & 2) {
@@ -1945,7 +1947,7 @@ fdc_data(fdc_t *fdc, uint8_t data, int last)
if (fdc->fifobufpos > 0)
fdc->fifobufpos = 0;
for (i = 0; i <= n; i++) {
for (int i = 0; i <= n; i++) {
result = dma_channel_write(fdc->dma_ch, fdc->fifobuf[i]);
if (result & DMA_OVER) {
@@ -2057,7 +2059,7 @@ fdc_writeprotect(fdc_t *fdc)
int
fdc_getdata(fdc_t *fdc, int last)
{
int i, data = 0;
int data = 0;
if ((fdc->flags & FDC_FLAG_PCJR) || !fdc->dma) {
if ((fdc->flags & FDC_FLAG_PCJR) || !fdc->fifo || (fdc->tfifo < 1)) {
@@ -2085,7 +2087,7 @@ fdc_getdata(fdc_t *fdc, int last)
}
} else {
if (fdc->fifobufpos == 0) {
for (i = 0; i <= fdc->tfifo; i++) {
for (int i = 0; i <= fdc->tfifo; i++) {
data = dma_channel_read(fdc->dma_ch);
fdc->fifobuf[i] = data;
@@ -2242,7 +2244,6 @@ fdc_remove(fdc_t *fdc)
void
fdc_reset(void *priv)
{
int i = 0;
uint8_t default_rwc;
fdc_t *fdc = (fdc_t *) priv;
@@ -2313,7 +2314,7 @@ fdc_reset(void *priv)
current_drive = 0;
for (i = 0; i < FDD_NUM; i++)
for (uint8_t i = 0; i < FDD_NUM; i++)
ui_sb_update_icon(SB_FLOPPY | i, 0);
}

23
src/floppy/fdd.c
View File

@@ -80,12 +80,14 @@ char *fdd_image_history[FDD_NUM][FLOPPY_IMAGE_HISTORY];
pc_timer_t fdd_poll_time[FDD_NUM];
static int fdd_notfound = 0,
driveloaders[FDD_NUM];
static int fdd_notfound = 0;
static int driveloaders[FDD_NUM];
int writeprot[FDD_NUM], fwriteprot[FDD_NUM],
fdd_changed[FDD_NUM], ui_writeprot[FDD_NUM] = { 0, 0, 0, 0 },
drive_empty[FDD_NUM] = { 1, 1, 1, 1 };
int writeprot[FDD_NUM];
int fwriteprot[FDD_NUM];
int fdd_changed[FDD_NUM];
int ui_writeprot[FDD_NUM] = { 0, 0, 0, 0 };
int drive_empty[FDD_NUM] = { 1, 1, 1, 1 };
DRIVE drives[FDD_NUM];
@@ -296,9 +298,7 @@ fdd_current_track(int drive)
void
fdd_set_densel(int densel)
{
int i = 0;
for (i = 0; i < FDD_NUM; i++) {
for (uint8_t i = 0; i < FDD_NUM; i++) {
if (drive_types[fdd[i].type].flags & FLAG_INVERT_DENSEL)
fdd[i].densel = densel ^ 1;
else
@@ -451,7 +451,8 @@ fdd_get_densel(int drive)
void
fdd_load(int drive, char *fn)
{
int c = 0, size;
int c = 0;
int size;
char *p;
FILE *f;
@@ -593,9 +594,7 @@ fdd_get_bitcell_period(int rate)
void
fdd_reset(void)
{
int i;
for (i = 0; i < FDD_NUM; i++) {
for (uint8_t i = 0; i < FDD_NUM; i++) {
drives[i].id = i;
timer_add(&(fdd_poll_time[i]), fdd_poll, &drives[i], 0);
}

131
src/floppy/fdd_86f.c
View File

@@ -231,7 +231,7 @@ static const uint8_t encoded_mfm[64] = {
static d86f_t *d86f[FDD_NUM];
static uint16_t CRCTable[256];
static fdc_t *d86f_fdc;
uint64_t poly = 0x42F0E1EBA9EA3693ll; /* ECMA normal */
uint64_t poly = 0x42F0E1EBA9EA3693LL; /* ECMA normal */
uint16_t d86f_side_flags(int drive);
int d86f_is_mfm(int drive);
@@ -261,7 +261,8 @@ d86f_log(const char *fmt, ...)
static void
setup_crc(uint16_t poly)
{
int c = 256, bc;
int c = 256;
int bc;
uint16_t temp;
while (c--) {
@@ -283,7 +284,8 @@ void
d86f_destroy_linked_lists(int drive, int side)
{
d86f_t *dev = d86f[drive];
sector_t *s, *t;
sector_t *s;
sector_t *t;
if (dev == NULL)
return;
@@ -432,7 +434,9 @@ d86f_side_flags(int drive)
uint16_t
d86f_track_flags(int drive)
{
uint16_t dr, rr, tf;
uint16_t dr;
uint16_t rr;
uint16_t tf;
tf = d86f_handler[drive].side_flags(drive);
rr = tf & 0x67;
@@ -468,10 +472,12 @@ uint32_t
common_get_raw_size(int drive, int side)
{
double rate = 0.0;
double rpm, rpm_diff;
double rpm;
double rpm_diff;
double size = 100000.0;
int mfm;
int rm, ssd;
int rm;
int ssd;
uint32_t extra_bc = 0;
mfm = d86f_is_mfm(drive);
@@ -601,7 +607,8 @@ int
d86f_get_array_size(int drive, int side, int words)
{
int array_size;
int hole, rm;
int hole;
int rm;
int ssd;
rm = d86f_get_rpm_mode(drive);
@@ -692,7 +699,8 @@ d86f_get_array_size(int drive, int side, int words)
int
d86f_valid_bit_rate(int drive)
{
int hole, rate;
int hole;
int rate;
rate = fdc_get_bit_rate(d86f_fdc);
hole = (d86f_handler[drive].disk_flags(drive) & 6) >> 1;
@@ -786,7 +794,8 @@ uint32_t
d86f_get_data_len(int drive)
{
d86f_t *dev = d86f[drive];
uint32_t i, ret = 128;
uint32_t i;
uint32_t ret = 128;
if (dev->req_sector.id.n)
ret = (uint32_t) 128 << dev->req_sector.id.n;
@@ -930,7 +939,9 @@ d86f_encode_byte(int drive, int sync, decoded_t b, decoded_t prev_b)
uint8_t bits89AB = prev_b.nibbles.nibble0;
uint8_t bits7654 = b.nibbles.nibble1;
uint8_t bits3210 = b.nibbles.nibble0;
uint16_t encoded_7654, encoded_3210, result;
uint16_t encoded_7654;
uint16_t encoded_3210;
uint16_t result;
if (encoding > 1)
return 0xffff;
@@ -1246,7 +1257,7 @@ d86f_find_address_mark_fm(int drive, int side, find_t *find, uint16_t req_am, ui
return;
}
if ((wrong_am) && (dev->last_word[side] == wrong_am)) {
if (wrong_am && (dev->last_word[side] == wrong_am)) {
dev->data_find.sync_marks = dev->data_find.bits_obtained = dev->data_find.bytes_obtained = 0;
dev->error_condition = 0;
dev->state = STATE_IDLE;
@@ -1311,7 +1322,7 @@ d86f_find_address_mark_mfm(int drive, int side, find_t *find, uint16_t req_am, u
return;
}
if ((wrong_am) && (dev->last_word[side] == wrong_am) && (find->sync_marks >= 3)) {
if (wrong_am && (dev->last_word[side] == wrong_am) && (find->sync_marks >= 3)) {
dev->data_find.sync_marks = dev->data_find.bits_obtained = dev->data_find.bytes_obtained = 0;
dev->error_condition = 0;
dev->state = STATE_IDLE;
@@ -1469,7 +1480,8 @@ uint8_t
d86f_get_data(int drive, int base)
{
d86f_t *dev = d86f[drive];
int data, byte_count;
int data;
int byte_count;
if (fdd_get_turbo(drive) && (dev->version == 0x0063))
byte_count = dev->turbo_pos;
@@ -1749,8 +1761,13 @@ void
d86f_write_direct_common(int drive, int side, uint16_t byte, uint8_t type, uint32_t pos)
{
d86f_t *dev = d86f[drive];
uint16_t encoded_byte = 0, mask_data, mask_surface, mask_hole, mask_fuzzy;
decoded_t dbyte, dpbyte;
uint16_t encoded_byte = 0;
uint16_t mask_data;
uint16_t mask_surface;
uint16_t mask_hole;
uint16_t mask_fuzzy;
decoded_t dbyte;
decoded_t dpbyte;
if (fdc_get_diswr(d86f_fdc))
return;
@@ -2062,7 +2079,8 @@ 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, *t;
sector_t *s;
sector_t *t;
if (dev->last_side_sector[side]) {
s = dev->last_side_sector[side];
@@ -2169,7 +2187,6 @@ d86f_turbo_format(int drive, int side, int nop)
int dat;
uint16_t sc;
uint16_t dtl;
int i;
sc = fdc_get_format_sectors(d86f_fdc);
dtl = 128 << fdc_get_format_n(d86f_fdc);
@@ -2187,7 +2204,7 @@ d86f_turbo_format(int drive, int side, int nop)
}
} else if (dev->datac == 4) {
if (!nop) {
for (i = 0; i < dtl; i++)
for (uint16_t i = 0; i < dtl; i++)
d86f_handler[drive].write_data(drive, side, i, dev->fill);
}
@@ -2213,7 +2230,8 @@ 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, *t;
sector_t *s;
sector_t *t;
if (dev->last_side_sector[side]) {
s = dev->last_side_sector[side];
@@ -2354,7 +2372,8 @@ void
d86f_poll(int drive)
{
d86f_t *dev = d86f[drive];
int mfm, side;
int mfm;
int side;
side = fdd_get_head(drive);
if (!fdd_is_double_sided(drive))
@@ -2750,11 +2769,18 @@ void
d86f_construct_encoded_buffer(int drive, int side)
{
d86f_t *dev = d86f[drive];
uint32_t i = 0;
/* *_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, src2_fuzm, dst_fuzm, src1_holm, src2_holm, dst_holm, dst_neim, src1_d, src2_d;
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];
@@ -2764,7 +2790,7 @@ d86f_construct_encoded_buffer(int drive, int side)
uint16_t *src2_s = dev->thin_track_surface_data[1][side];
len = d86f_get_array_size(drive, side, 1);
for (i = 0; i < len; i++) {
for (uint32_t i = 0; i < len; i++) {
/* The two bits differ. */
if (d86f_has_surface_desc(drive)) {
/* Source image has surface description data, so we have some more handling to do. */
@@ -2799,8 +2825,8 @@ void
d86f_decompose_encoded_buffer(int drive, int side)
{
d86f_t *dev = d86f[drive];
uint32_t i = 0;
uint16_t temp, temp2;
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];
@@ -2810,7 +2836,7 @@ d86f_decompose_encoded_buffer(int drive, int side)
dst = d86f_handler[drive].encoded_data(drive, side);
len = d86f_get_array_size(drive, side, 1);
for (i = 0; i < len; i++) {
for (uint32_t i = 0; i < len; i++) {
if (d86f_has_surface_desc(drive)) {
/* Source image has surface description data, so we have some more handling to do.
We need hole masks for both buffers. Holes have data bit clear and surface bit set. */
@@ -2901,10 +2927,10 @@ void
d86f_zero_track(int drive)
{
d86f_t *dev = d86f[drive];
int sides, side;
int sides;
sides = d86f_get_sides(drive);
for (side = 0; side < sides; side++) {
for (int side = 0; side < sides; side++) {
if (d86f_has_surface_desc(drive))
memset(dev->track_surface_data[side], 0, 106096);
memset(dev->track_encoded_data[side], 0, 106096);
@@ -2916,7 +2942,8 @@ d86f_seek(int drive, int track)
{
d86f_t *dev = d86f[drive];
int sides;
int side, thin_track;
int side;
int thin_track;
sides = d86f_get_sides(drive);
/* If the drive has thick tracks, shift the track number by 1. */
@@ -2995,8 +3022,9 @@ void
d86f_write_tracks(int drive, FILE **f, uint32_t *track_table)
{
d86f_t *dev = d86f[drive];
int sides, fdd_side;
int side, thin_track;
int sides;
int fdd_side;
int side;
int logical_track = 0;
uint32_t *tbl;
tbl = dev->track_offset;
@@ -3011,7 +3039,7 @@ d86f_write_tracks(int drive, FILE **f, uint32_t *track_table)
if (sides == 2)
d86f_decompose_encoded_buffer(drive, 1);
for (thin_track = 0; thin_track < 2; thin_track++) {
for (uint8_t thin_track = 0; thin_track < 2; thin_track++) {
for (side = 0; side < sides; side++) {
fdd_set_head(drive, side);
@@ -3060,7 +3088,8 @@ d86f_writeback(int drive)
{
d86f_t *dev = d86f[drive];
uint8_t header[32];
int header_size, size;
int header_size;
int size;
#ifdef D86F_COMPRESS
uint32_t len;
int ret = 0;
@@ -3264,8 +3293,8 @@ void
d86f_common_format(int drive, int side, int rate, uint8_t fill, int proxy)
{
d86f_t *dev = d86f[drive];
uint32_t i = 0;
uint16_t temp, temp2;
uint16_t temp;
uint16_t temp2;
uint32_t array_size;
if (writeprot[drive]) {
@@ -3297,7 +3326,7 @@ d86f_common_format(int drive, int side, int rate, uint8_t fill, int proxy)
if (d86f_has_surface_desc(drive)) {
/* Preserve the physical holes but get rid of the fuzzy bytes. */
for (i = 0; i < array_size; i++) {
for (uint32_t i = 0; i < array_size; i++) {
temp = dev->track_encoded_data[side][i] ^ 0xffff;
temp2 = dev->track_surface_data[side][i];
temp &= temp2;
@@ -3366,7 +3395,6 @@ d86f_export(int drive, char *fn)
d86f_t *temp86;
FILE *f;
int tracks = 86;
int i;
int inc = 1;
uint32_t magic = 0x46423638;
uint16_t version = 0x020C;
@@ -3393,7 +3421,7 @@ d86f_export(int drive, char *fn)
if (!fdd_doublestep_40(drive))
inc = 2;
for (i = 0; i < tracks; i += inc) {
for (int i = 0; i < tracks; i += inc) {
if (inc == 2)
fdd_do_seek(drive, i >> 1);
else
@@ -3426,7 +3454,6 @@ d86f_load(int drive, char *fn)
d86f_t *dev = d86f[drive];
uint32_t magic = 0;
uint32_t len = 0;
int i = 0, j = 0;
#ifdef D86F_COMPRESS
char temp_file_name[2048];
uint16_t temp = 0;
@@ -3501,11 +3528,11 @@ d86f_load(int drive, char *fn)
(void) !fread(&(dev->disk_flags), 2, 1, dev->f);
if (d86f_has_surface_desc(drive)) {
for (i = 0; i < 2; i++)
for (uint8_t i = 0; i < 2; i++)
dev->track_surface_data[i] = (uint16_t *) malloc(53048 * sizeof(uint16_t));
for (i = 0; i < 2; i++) {
for (j = 0; j < 2; j++)
for (uint8_t i = 0; i < 2; i++) {
for (uint8_t j = 0; j < 2; j++)
dev->thin_track_surface_data[i][j] = (uint16_t *) malloc(53048 * sizeof(uint16_t));
}
}
@@ -3750,11 +3777,9 @@ d86f_load(int drive, char *fn)
void
d86f_init(void)
{
int i;
setup_crc(0x1021);
for (i = 0; i < FDD_NUM; i++)
for (uint8_t i = 0; i < FDD_NUM; i++)
d86f[i] = NULL;
}
@@ -3767,8 +3792,6 @@ d86f_set_fdc(void *fdc)
void
d86f_close(int drive)
{
int i, j;
char temp_file_name[2048];
d86f_t *dev = d86f[drive];
@@ -3779,15 +3802,15 @@ d86f_close(int drive)
memcpy(temp_file_name, drive ? nvr_path("TEMP$$$1.$$$") : nvr_path("TEMP$$$0.$$$"), 26);
if (d86f_has_surface_desc(drive)) {
for (i = 0; i < 2; i++) {
for (uint8_t i = 0; i < 2; i++) {
if (dev->track_surface_data[i]) {
free(dev->track_surface_data[i]);
dev->track_surface_data[i] = NULL;
}
}
for (i = 0; i < 2; i++) {
for (j = 0; j < 2; j++) {
for (uint8_t i = 0; i < 2; i++) {
for (uint8_t j = 0; j < 2; j++) {
if (dev->thin_track_surface_data[i][j]) {
free(dev->thin_track_surface_data[i][j]);
dev->thin_track_surface_data[i][j] = NULL;
@@ -3828,23 +3851,21 @@ d86f_setup(int drive)
void
d86f_destroy(int drive)
{
int i, j;
d86f_t *dev = d86f[drive];
if (dev == NULL)
return;
if (d86f_has_surface_desc(drive)) {
for (i = 0; i < 2; i++) {
for (uint8_t i = 0; i < 2; i++) {
if (dev->track_surface_data[i]) {
free(dev->track_surface_data[i]);
dev->track_surface_data[i] = NULL;
}
}
for (i = 0; i < 2; i++) {
for (j = 0; j < 2; j++) {
for (uint8_t i = 0; i < 2; i++) {
for (uint8_t j = 0; j < 2; j++) {
if (dev->thin_track_surface_data[i][j]) {
free(dev->thin_track_surface_data[i][j]);
dev->thin_track_surface_data[i][j] = NULL;

10
src/floppy/fdd_common.c
View File

@@ -398,7 +398,7 @@ fdd_sector_size_code(int size)
break;
}
return (ret);
return ret;
}
int
@@ -410,15 +410,13 @@ fdd_sector_code_size(uint8_t code)
int
fdd_bps_valid(uint16_t bps)
{
int i;
for (i = 0; i <= 8; i++) {
for (uint8_t i = 0; i <= 8; i++) {
if (bps == (128 << i)) {
return 1;
}
}
return (0);
return 0;
}
int
@@ -435,5 +433,5 @@ fdd_interleave(int sector, int skew, int spt)
adjusted_r += (adjust + add);
}
return (adjusted_r);
return adjusted_r;
}

23
src/floppy/fdd_fdi.c
View File

@@ -104,7 +104,7 @@ disk_flags(int drive)
*/
temp_disk_flags |= 0x800;
return (temp_disk_flags);
return temp_disk_flags;
}
static uint16_t
@@ -143,34 +143,34 @@ side_flags(int drive)
*/
temp_side_flags |= 0x08;
return (temp_side_flags);
return temp_side_flags;
}
static int
fdi_density(void)
{
if (!fdc_is_mfm(fdi_fdc))
return (0);
return 0;
switch (fdc_get_bit_rate(fdi_fdc)) {
case 0:
return (2);
return 2;
case 1:
return (1);
return 1;
case 2:
return (1);
return 1;
case 3:
case 5:
return (3);
return 3;
default:
break;
}
return (1);
return 1;
}
static int32_t
@@ -207,14 +207,15 @@ extra_bit_cells(int drive, int side)
raw_size = is_300_rpm ? 100000 : 83333;
}
return ((dev->tracklen[side][density] - raw_size));
return (dev->tracklen[side][density] - raw_size);
}
static void
read_revolution(int drive)
{
fdi_t *dev = fdi[drive];
int c, den, side;
int c;
int den;
int track = dev->track;
if (track > dev->lasttrack) {
@@ -227,7 +228,7 @@ read_revolution(int drive)
}
for (den = 0; den < 4; den++) {
for (side = 0; side < dev->sides; side++) {
for (int side = 0; side < dev->sides; side++) {
c = fdi2raw_loadtrack(dev->h,
(uint16_t *) dev->track_data[side][den],
(uint16_t *) dev->track_timing[side][den],

91
src/floppy/fdd_imd.c
View File

@@ -129,16 +129,21 @@ get_raw_tsize(int side_flags, int slower_rpm)
break;
}
return (size);
return size;
}
static int
track_is_xdf(int drive, int side, int track)
{
imd_t *dev = imd[drive];
int i, effective_sectors, xdf_sectors;
int high_sectors, low_sectors;
int max_high_id, expected_high_count, expected_low_count;
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;
@@ -148,16 +153,16 @@ track_is_xdf(int drive, int side, int track)
dev->xdf_ordered_pos[i][side] = 0;
if (dev->tracks[track][side].params[2] & 0xC0)
return (0);
return 0;
if ((dev->tracks[track][side].params[3] != 16) && (dev->tracks[track][side].params[3] != 19))
return (0);
return 0;
r_map = (uint8_t *) (dev->buffer + dev->tracks[track][side].r_map_offs);
if (!track) {
if (dev->tracks[track][side].params[4] != 2)
return (0);
return 0;
if (!side) {
max_high_id = (dev->tracks[track][side].params[3] == 19) ? 0x8B : 0x88;
@@ -183,10 +188,10 @@ track_is_xdf(int drive, int side, int track)
return ((dev->tracks[track][side].params[3] == 19) ? 2 : 1);
}
}
return (0);
return 0;
} else {
if (dev->tracks[track][side].params[4] != 0xFF)
return (0);
return 0;
n_map = (uint8_t *) (dev->buffer + dev->tracks[track][side].n_map_offs);
@@ -203,31 +208,31 @@ track_is_xdf(int drive, int side, int track)
if ((effective_sectors == 3) && (xdf_sectors == 3)) {
dev->current_side_flags[side] = 0x28;
return (1); /* 5.25" 2HD XDF */
return 1; /* 5.25" 2HD XDF */
}
if ((effective_sectors == 4) && (xdf_sectors == 4)) {
dev->current_side_flags[side] = 0x08;
return (2); /* 3.5" 2HD XDF */
return 2; /* 3.5" 2HD XDF */
}
return (0);
return 0;
}
return (0);
return 0;
}
static int
track_is_interleave(int drive, int side, int track)
{
imd_t *dev = imd[drive];
int i, effective_sectors;
int effective_sectors;
char *r_map;
int track_spt;
effective_sectors = 0;
for (i = 0; i < 256; i++)
for (uint16_t i = 0; i < 256; i++)
dev->interleave_ordered_pos[i][side] = 0;
track_spt = dev->tracks[track][side].params[3];
@@ -235,15 +240,15 @@ track_is_interleave(int drive, int side, int track)
r_map = dev->buffer + dev->tracks[track][side].r_map_offs;
if (dev->tracks[track][side].params[2] & 0xC0)
return (0);
return 0;
if (track_spt != 21)
return (0);
return 0;
if (dev->tracks[track][side].params[4] != 2)
return (0);
return 0;
for (i = 0; i < track_spt; i++) {
for (int i = 0; i < track_spt; i++) {
if ((r_map[i] >= 1) && (r_map[i] <= track_spt)) {
effective_sectors++;
dev->interleave_ordered_pos[(int) r_map[i]][side] = i;
@@ -251,9 +256,9 @@ track_is_interleave(int drive, int side, int track)
}
if (effective_sectors == track_spt)
return (1);
return 1;
return (0);
return 0;
}
static void
@@ -282,8 +287,11 @@ imd_seek(int drive, int track)
uint8_t id[4] = { 0, 0, 0, 0 };
uint8_t type;
imd_t *dev = imd[drive];
int sector, current_pos;
int side, c = 0, h, n;
int sector;
int current_pos;
int c = 0;
int h;
int n;
int ssize = 512;
int track_rate = 0;
int track_gap2 = 22;
@@ -329,7 +337,7 @@ imd_seek(int drive, int track)
if (track > dev->track_count)
return;
for (side = 0; side < dev->sides; side++) {
for (int side = 0; side < dev->sides; side++) {
if (!dev->tracks[track][side].is_present)
continue;
@@ -460,7 +468,7 @@ side_flags(int drive)
side = fdd_get_head(drive);
sflags = dev->current_side_flags[side];
return (sflags);
return sflags;
}
static void
@@ -468,8 +476,13 @@ 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 i, sc, sh, sn;
char *c_map = NULL, *h_map = NULL, *r_map = NULL, *n_map = NULL;
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];
@@ -487,7 +500,7 @@ set_sector(int drive, int side, uint8_t c, uint8_t h, uint8_t r, uint8_t n)
if (c != dev->track)
return;
for (i = 0; i < dev->tracks[track][side].params[3]; i++) {
for (uint8_t i = 0; i < dev->tracks[track][side].params[3]; i++) {
id[0] = (sh & 0x80) ? c_map[i] : sc;
id[1] = (sh & 0x40) ? h_map[i] : (sh & 1);
id[2] = r_map[i];
@@ -502,17 +515,17 @@ static void
imd_writeback(int drive)
{
imd_t *dev = imd[drive];
int side;
int track = dev->track;
int i = 0;
char *n_map = 0;
uint8_t h, n, spt;
uint8_t h;
uint8_t n;
uint8_t spt;
uint32_t ssize;
if (writeprot[drive])
return;
for (side = 0; side < dev->sides; side++) {
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);
h = dev->tracks[track][side].params[2];
@@ -530,7 +543,7 @@ imd_writeback(int drive)
n_map = dev->buffer + dev->tracks[track][side].n_map_offs;
fwrite(n_map, 1, spt, dev->f);
}
for (i = 0; i < spt; i++) {
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);
@@ -546,7 +559,7 @@ poll_read_data(int drive, int side, uint16_t pos)
int type = dev->current_data[side][0];
if ((type == 0) || (type > 8))
return (0xf6); /* Should never happen. */
return 0xf6; /* Should never happen. */
if (type & 1)
return (dev->current_data[side][pos + 1]);
@@ -574,13 +587,14 @@ format_conditions(int drive)
{
imd_t *dev = imd[drive];
int track = dev->track;
int side, temp;
int side;
int temp;
side = fdd_get_head(drive);
temp = (fdc_get_format_sectors(imd_fdc) == dev->tracks[track][side].params[3]);
temp = temp && (fdc_get_format_n(imd_fdc) == dev->tracks[track][side].params[4]);
return (temp);
return temp;
}
void
@@ -613,7 +627,8 @@ imd_load(int drive, char *fn)
uint32_t minimum_gap4 = 0;
uint8_t converted_rate;
uint8_t type;
int size_diff, gap_sum;
int size_diff;
int gap_sum;
d86f_unregister(drive);
@@ -708,7 +723,7 @@ imd_load(int drive, char *fn)
dev->tracks[track][side].side_flags = (buffer2[0] % 3);
if (!dev->tracks[track][side].side_flags)
dev->disk_flags |= (0x02);
dev->disk_flags |= 0x02;
dev->tracks[track][side].side_flags |= (!(buffer2[0] - dev->tracks[track][side].side_flags) ? 0 : 8);
mfm = dev->tracks[track][side].side_flags & 8;
track_total = mfm ? 146 : 73;

65
src/floppy/fdd_img.c
View File

@@ -42,7 +42,7 @@
typedef struct {
FILE *f;
uint8_t track_data[2][50000];
uint8_t track_data[2][688128];
int sectors, tracks, sides;
uint8_t sector_size;
int xdf_type; /* 0 = not XDF, 1-5 = one of the five XDF types */
@@ -71,10 +71,10 @@ static fdc_t *img_fdc;
static double bit_rate_300;
static char *ext;
static uint8_t first_byte,
second_byte,
third_byte,
fourth_byte;
static uint8_t first_byte;
static uint8_t second_byte;
static uint8_t third_byte;
static uint8_t fourth_byte;
static uint8_t fdf_suppress_final_byte = 0; /* This is hard-coded to 0 -
* if you really need to read
* those NT 3.1 Beta floppy
@@ -339,43 +339,41 @@ sector_size_code(int sector_size)
{
switch (sector_size) {
case 128:
return (0);
return 0;
case 256:
return (1);
return 1;
default:
case 512:
return (2);
return 2;
case 1024:
return (3);
return 3;
case 2048:
return (4);
return 4;
case 4096:
return (5);
return 5;
case 8192:
return (6);
return 6;
case 16384:
return (7);
return 7;
}
}
static int
bps_is_valid(uint16_t bps)
{
int i;
for (i = 0; i <= 8; i++) {
for (uint8_t i = 0; i <= 8; i++) {
if (bps == (128 << i))
return (1);
return 1;
}
return (0);
return 0;
}
static int
@@ -385,13 +383,13 @@ first_byte_is_valid(uint8_t first_byte)
case 0x60:
case 0xE9:
case 0xEB:
return (1);
return 1;
default:
break;
}
return (0);
return 0;
}
#define xdf_img_sector xdf_img_layout[current_xdft][!is_t0][sector]
@@ -410,7 +408,7 @@ interleave(int sector, int skew, int track_spt)
if (skewed_i & 1)
adjusted_r += (adjust + add);
return (adjusted_r);
return adjusted_r;
}
static void
@@ -418,7 +416,7 @@ write_back(int drive)
{
img_t *dev = img[drive];
int ssize = 128 << ((int) dev->sector_size);
int side, size;
int size;
if (dev->f == NULL)
return;
@@ -428,7 +426,7 @@ write_back(int drive)
if (fseek(dev->f, 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 (side = 0; side < dev->sides; side++) {
for (int side = 0; side < dev->sides; side++) {
size = dev->sectors * ssize;
if (fwrite(dev->track_data[side], 1, size, dev->f) != size)
fatal("IMG write_back(): Error writing data\n");
@@ -485,7 +483,7 @@ format_conditions(int drive)
temp = temp && (fdc_get_format_n(img_fdc) == dev->sector_size);
temp = temp && (dev->xdf_type == 0);
return (temp);
return temp;
}
static void
@@ -496,7 +494,16 @@ img_seek(int drive, int track)
int current_xdft = dev->xdf_type - 1;
int read_bytes = 0;
uint8_t id[4] = { 0, 0, 0, 0 };
int is_t0, sector, current_pos, img_pos, sr, sside, total, array_sector, buf_side, buf_pos;
int is_t0;
int sector;
int current_pos;
int img_pos;
int sr;
int sside;
int total;
int array_sector;
int buf_side;
int buf_pos;
int ssize = 128 << ((int) dev->sector_size);
uint32_t cur_pos = 0;
@@ -647,7 +654,10 @@ img_load(int drive, char *fn)
uint8_t bpb_mid; /* Media type ID. */
uint8_t bpb_sectors;
uint8_t bpb_sides;
uint8_t cqm, ddi, fdf, fdi;
uint8_t cqm;
uint8_t ddi;
uint8_t fdf;
uint8_t fdi;
uint16_t comment_len = 0;
int16_t block_len = 0;
uint32_t cur_pos = 0;
@@ -661,7 +671,6 @@ img_load(int drive, char *fn)
int temp_rate;
int guess = 0;
int size;
int i;
ext = path_get_extension(fn);
@@ -1152,7 +1161,7 @@ jump_if_fdf:
temp_rate = 0xFF;
}
for (i = 0; i < 6; i++) {
for (uint8_t i = 0; i < 6; i++) {
if ((dev->sectors <= maximum_sectors[dev->sector_size][i]) || (dev->sectors == xdf_sectors[dev->sector_size][i])) {
bit_rate_300 = bit_rates_300[i];
temp_rate = rates[i];

49
src/floppy/fdd_json.c
View File

@@ -125,10 +125,11 @@ static void
handle(json_t *dev, char *name, char *str)
{
sector_t *sec = NULL;
uint32_t l, pat;
uint32_t l;
uint32_t pat;
uint8_t *p;
char *sp;
int i, s;
int s;
/* Point to the currently selected sector. */
sec = &dev->sects[dev->track][dev->side][dev->dmf - 1];
@@ -163,7 +164,7 @@ handle(json_t *dev, char *name, char *str)
sec->data = (uint8_t *) malloc(sec->size);
p = sec->data;
s = (sec->size / sizeof(uint32_t));
for (i = 0; i < s; i++) {
for (int i = 0; i < s; i++) {
l = pat;
*p++ = (l & 0x000000ff);
l >>= 8;
@@ -207,18 +208,21 @@ unexpect(int c, int state, int level)
static int
load_image(json_t *dev)
{
char buff[4096], name[32];
int c, i, j, state, level;
char buff[4096];
char name[32];
int c;
int state;
int level;
char *ptr;
if (dev->f == NULL) {
json_log("JSON: no file loaded!\n");
return (0);
return 0;
}
/* Initialize. */
for (i = 0; i < NTRACKS; i++) {
for (j = 0; j < NSIDES; j++)
for (uint16_t i = 0; i < NTRACKS; i++) {
for (uint8_t j = 0; j < NSIDES; j++)
memset(dev->sects[i][j], 0x00, sizeof(sector_t));
}
dev->track = dev->side = dev->dmf = 0; /* "dmf" is "sector#" */
@@ -375,7 +379,7 @@ load_image(json_t *dev)
dev->tracks = dev->track;
dev->sides = dev->side;
return (1);
return 1;
}
/* Seek the heads to a track, and prepare to read data from that track. */
@@ -384,9 +388,13 @@ json_seek(int drive, int track)
{
uint8_t id[4] = { 0, 0, 0, 0 };
json_t *dev = images[drive];
int side, sector;
int rate, gap2, gap3, pos;
int ssize, rsec, asec;
int rate;
int gap2;
int gap3;
int pos;
int ssize;
int rsec;
int asec;
if (dev->f == NULL) {
json_log("JSON: seek: no file loaded!\n");
@@ -412,7 +420,7 @@ json_seek(int drive, int track)
return;
}
for (side = 0; side < dev->sides; side++) {
for (uint8_t side = 0; side < dev->sides; side++) {
/* Get transfer rate for this side. */
rate = dev->track_flags & 0x07;
if (!rate && (dev->track_flags & 0x20))
@@ -428,7 +436,7 @@ json_seek(int drive, int track)
pos = d86f_prepare_pretrack(drive, side, 0);
for (sector = 0; sector < dev->spt[track][side]; sector++) {
for (uint8_t sector = 0; sector < dev->spt[track][side]; sector++) {
rsec = dev->sects[track][side][sector].sector;
asec = sector;
@@ -473,7 +481,6 @@ static void
set_sector(int drive, int side, uint8_t c, uint8_t h, uint8_t r, uint8_t n)
{
json_t *dev = images[drive];
int i;
dev->sector[side] = 0;
@@ -485,7 +492,7 @@ set_sector(int drive, int side, uint8_t c, uint8_t h, uint8_t r, uint8_t n)
dev->side = side;
/* Now loop over all sector ID's on this side to find our sector. */
for (i = 0; i < dev->spt[c][side]; i++) {
for (uint8_t i = 0; i < dev->spt[c][side]; i++) {
if ((dev->sects[dev->track][side][i].track == c) && (dev->sects[dev->track][side][i].side == h) && (dev->sects[dev->track][side][i].sector == r) && (dev->sects[dev->track][side][i].size == n)) {
dev->sector[side] = i;
}
@@ -514,7 +521,6 @@ json_load(int drive, char *fn)
int temp_rate;
sector_t *sec;
json_t *dev;
int i;
/* Just in case- remove ourselves from 86F. */
d86f_unregister(drive);
@@ -571,7 +577,7 @@ json_load(int drive, char *fn)
temp_rate = 0xff;
sec = &dev->sects[0][0][0];
for (i = 0; i < 6; i++) {
for (uint8_t i = 0; i < 6; i++) {
if (dev->spt[0][0] > fdd_max_sectors[sec->size][i])
continue;
@@ -667,7 +673,6 @@ void
json_close(int drive)
{
json_t *dev = images[drive];
int t, h, s;
if (dev == NULL)
return;
@@ -676,10 +681,10 @@ json_close(int drive)
d86f_unregister(drive);
/* Release all the sector buffers. */
for (t = 0; t < 256; t++) {
for (h = 0; h < 2; h++) {
for (uint16_t t = 0; t < 256; t++) {
for (uint8_t h = 0; h < 2; h++) {
memset(dev->sects[t][h], 0x00, sizeof(sector_t));
for (s = 0; s < 256; s++) {
for (uint16_t s = 0; s < 256; s++) {
if (dev->sects[t][h][s].data != NULL)
free(dev->sects[t][h][s].data);
dev->sects[t][h][s].data = NULL;

30
src/floppy/fdd_mfm.c
View File

@@ -103,9 +103,9 @@ static int
get_track_index(int drive, int side, int track)
{
mfm_t *dev = mfm[drive];
int i, ret = -1;
int ret = -1;
for (i = 0; i < dev->total_tracks; i++) {
for (int i = 0; i < dev->total_tracks; i++) {
if ((dev->tracks[i].track_no == track) && (dev->tracks[i].side_no == side)) {
ret = i;
break;
@@ -119,9 +119,9 @@ static int
get_adv_track_index(int drive, int side, int track)
{
mfm_t *dev = mfm[drive];
int i, ret = -1;
int ret = -1;
for (i = 0; i < dev->total_tracks; i++) {
for (int i = 0; i < dev->total_tracks; i++) {
if ((dev->adv_tracks[i].track_no == track) && (dev->adv_tracks[i].side_no == side)) {
ret = i;
break;
@@ -154,7 +154,8 @@ get_adv_track_bitrate(int drive, int side, int track, int *br, int *rpm)
static void
set_disk_flags(int drive)
{
int br = 250, rpm = 300;
int br = 250;
int rpm = 300;
mfm_t *dev = mfm[drive];
uint16_t temp_disk_flags = 0x1080; /* We ALWAYS claim to have extra bit cells, even if the actual amount is 0;
Bit 12 = 1, bits 6, 5 = 0 - extra bit cells field specifies the entire
@@ -203,7 +204,8 @@ set_side_flags(int drive, int side)
{
mfm_t *dev = mfm[drive];
uint16_t temp_side_flags = 0;
int br = 250, rpm = 300;
int br = 250;
int rpm = 300;
if (dev->hdr.if_type & 0x80)
get_adv_track_bitrate(drive, side, dev->cur_track, &br, &rpm);
@@ -264,8 +266,10 @@ static uint32_t
get_raw_size(int drive, int side)
{
mfm_t *dev = mfm[drive];
int track_index, is_300_rpm;
int br = 250, rpm = 300;
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);
@@ -319,8 +323,10 @@ void
mfm_read_side(int drive, int side)
{
mfm_t *dev = mfm[drive];
int track_index, track_size;
int track_bytes, ret;
int track_index;
int track_size;
int track_bytes;
int ret;
if (dev->hdr.if_type & 0x80)
track_index = get_adv_track_index(drive, side, dev->cur_track);
@@ -382,7 +388,7 @@ mfm_load(int drive, char *fn)
{
mfm_t *dev;
double dbr;
int i, size;
int size;
writeprot[drive] = fwriteprot[drive] = 1;
@@ -427,7 +433,7 @@ mfm_load(int drive, char *fn)
dev->hdr.tracks_no >>= 1;
dev->hdr.sides_no <<= 1;
for (i = 0; i < dev->total_tracks; i++) {
for (int i = 0; i < dev->total_tracks; i++) {
if (dev->hdr.if_type & 0x80) {
dev->adv_tracks[i].side_no <<= 1;
dev->adv_tracks[i].side_no |= (dev->adv_tracks[i].track_no & 1);

137
src/floppy/fdd_td0.c
View File

@@ -237,11 +237,11 @@ dsk_identify(int drive)
fdd_image_read(drive, header, 0, 2);
if (header[0] == 'T' && header[1] == 'D')
return (1);
return 1;
else if (header[0] == 't' && header[1] == 'd')
return (1);
return 1;
return (0);
return 0;
}
static int
@@ -259,7 +259,7 @@ state_data_read(td0dsk_t *state, uint8_t *buf, uint16_t size)
fatal("TD0: Error reading data in state_data_read()\n");
state->fdd_file_offset += size;
return (size);
return size;
}
static int
@@ -277,7 +277,7 @@ state_next_word(td0dsk_t *state)
state->getlen += 8;
}
return (0);
return 0;
}
/* get one bit */
@@ -293,9 +293,9 @@ state_GetBit(td0dsk_t *state)
state->getbuf <<= 1;
state->getlen--;
if (i < 0)
return (1);
return 1;
return (0);
return 0;
}
/* get a byte */
@@ -305,7 +305,7 @@ state_GetByte(td0dsk_t *state)
uint16_t i;
if (state_next_word(state) != 0)
return (-1);
return -1;
i = state->getbuf;
state->getbuf <<= 8;
@@ -319,7 +319,8 @@ state_GetByte(td0dsk_t *state)
static void
state_StartHuff(td0dsk_t *state)
{
int i, j;
int i;
int j;
for (i = 0; i < N_CHAR; i++) {
state->freq[i] = 1;
@@ -343,8 +344,11 @@ state_StartHuff(td0dsk_t *state)
static void
state_reconst(td0dsk_t *state)
{
int16_t i, j, k;
uint16_t f, l;
int16_t i;
int16_t j;
int16_t k;
uint16_t f;
uint16_t l;
/* halven cumulative freq for leaf nodes */
j = 0;
@@ -385,7 +389,10 @@ state_reconst(td0dsk_t *state)
static void
state_update(td0dsk_t *state, int c)
{
int i, j, k, l;
int i;
int j;
int k;
int l;
if (state->freq[R] == MAX_FREQ)
state_reconst(state);
@@ -444,14 +451,16 @@ state_DecodeChar(td0dsk_t *state)
state_update(state, c);
return (c);
return c;
}
static int16_t
state_DecodePosition(td0dsk_t *state)
{
int16_t bit;
uint16_t i, j, c;
uint16_t i;
uint16_t j;
uint16_t c;
/* decode upper 6 bits from given table */
if ((bit = state_GetByte(state)) < 0)
@@ -476,15 +485,13 @@ state_DecodePosition(td0dsk_t *state)
static void
state_init_Decode(td0dsk_t *state)
{
int i;
state->getbuf = 0;
state->getlen = 0;
state->tdctl.ibufcnt = state->tdctl.ibufndx = 0; /* input buffer is empty */
state->tdctl.bufcnt = 0;
state_StartHuff(state);
for (i = 0; i < N - F; i++)
for (uint16_t i = 0; i < N - F; i++)
state->text_buf[i] = ' ';
state->tdctl.r = N - F;
@@ -494,13 +501,14 @@ state_init_Decode(td0dsk_t *state)
static int
state_Decode(td0dsk_t *state, uint8_t *buf, int len)
{
int16_t c, pos;
int16_t c;
int16_t pos;
int count; /* was an unsigned long, seems unnecessary */
for (count = 0; count < len;) {
if (state->tdctl.bufcnt == 0) {
if ((c = state_DecodeChar(state)) < 0)
return (count); /* fatal error */
return count; /* fatal error */
if (c < 256) {
*(buf++) = c & 0xff;
state->text_buf[state->tdctl.r++] = c & 0xff;
@@ -508,7 +516,7 @@ state_Decode(td0dsk_t *state, uint8_t *buf, int len)
count++;
} else {
if ((pos = state_DecodePosition(state)) < 0)
return (count); /* fatal error */
return count; /* fatal error */
state->tdctl.bufpos = (state->tdctl.r - pos - 1) & (N - 1);
state->tdctl.bufcnt = c - 255 + THRESHOLD;
state->tdctl.bufndx = 0;
@@ -530,7 +538,7 @@ state_Decode(td0dsk_t *state, uint8_t *buf, int len)
}
}
return (count); /* count == len, success */
return count; /* count == len, success */
}
static uint32_t
@@ -578,7 +586,7 @@ get_raw_tsize(int side_flags, int slower_rpm)
break;
}
return (size);
return size;
}
static int
@@ -586,15 +594,19 @@ td0_initialize(int drive)
{
td0_t *dev = td0[drive];
uint8_t header[12];
int fm, head, track;
int fm;
int head;
int track;
int track_count = 0;
int head_count = 0;
int track_spt, track_spt_adjusted;
int track_spt;
int track_spt_adjusted;
int offset = 0;
int density = 0;
int temp_rate = 0;
uint32_t file_size;
uint16_t len, rep;
uint16_t len;
uint16_t rep;
td0dsk_t disk_decode;
uint8_t *hs;
uint16_t size;
@@ -606,12 +618,15 @@ td0_initialize(int drive)
int32_t raw_tsize = 0;
uint32_t minimum_gap3 = 0;
uint32_t minimum_gap4 = 0;
int i, j, k;
int size_diff, gap_sum;
int i;
int j;
int k;
int size_diff;
int gap_sum;
if (dev->f == NULL) {
td0_log("TD0: Attempted to initialize without loading a file first\n");
return (0);
return 0;
}
fseek(dev->f, 0, SEEK_END);
@@ -619,12 +634,12 @@ td0_initialize(int drive)
if (file_size < 12) {
td0_log("TD0: File is too small to even contain the header\n");
return (0);
return 0;
}
if (file_size > TD0_MAX_BUFSZ) {
td0_log("TD0: File exceeds the maximum size\n");
return (0);
return 0;
}
fseek(dev->f, 0, SEEK_SET);
@@ -652,14 +667,14 @@ td0_initialize(int drive)
if (track_spt == 255) {
/* Empty file? */
td0_log("TD0: File has no tracks\n");
return (0);
return 0;
}
density = (header[5] >> 1) & 3;
if (density == 3) {
td0_log("TD0: Unknown density\n");
return (0);
return 0;
}
/*
@@ -737,7 +752,7 @@ td0_initialize(int drive)
size = 128 << hs[3];
if ((total_size + size) >= TD0_MAX_BUFSZ) {
td0_log("TD0: Processed buffer overflow\n");
return (0);
return 0;
}
if (hs[4] & 0x30)
@@ -747,7 +762,7 @@ td0_initialize(int drive)
switch (hs[8]) {
default:
td0_log("TD0: Image uses an unsupported sector data encoding: %i\n", hs[8]);
return (0);
return 0;
case 0:
memcpy(dbuf, &dev->imagebuf[offset], size);
@@ -862,7 +877,7 @@ td0_initialize(int drive)
td0_log("TD0: File loaded: %i tracks, %i sides, disk flags: %02X, side flags: %02X, %02X, GAP3 length: %02X\n", dev->tracks, dev->sides, dev->disk_flags, dev->current_side_flags[0], dev->current_side_flags[1], dev->gap3_len);
return (1);
return 1;
}
static uint16_t
@@ -883,19 +898,19 @@ side_flags(int drive)
side = fdd_get_head(drive);
sflags = dev->current_side_flags[side];
return (sflags);
return sflags;
}
static void
set_sector(int drive, int side, uint8_t c, uint8_t h, uint8_t r, uint8_t n)
{
td0_t *dev = td0[drive];
int i = 0, cyl = c;
int cyl = c;
dev->current_sector_index[side] = 0;
if (cyl != dev->track)
return;
for (i = 0; i < dev->track_spt[cyl][side]; i++) {
for (uint8_t i = 0; i < dev->track_spt[cyl][side]; i++) {
if ((dev->sects[cyl][side][i].track == c) && (dev->sects[cyl][side][i].head == h) && (dev->sects[cyl][side][i].sector == r) && (dev->sects[cyl][side][i].size == n)) {
dev->current_sector_index[side] = i;
}
@@ -915,9 +930,14 @@ track_is_xdf(int drive, int side, int track)
{
td0_t *dev = td0[drive];
uint8_t id[4] = { 0, 0, 0, 0 };
int i, effective_sectors, xdf_sectors;
int high_sectors, low_sectors;
int max_high_id, expected_high_count, expected_low_count;
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;
effective_sectors = xdf_sectors = high_sectors = low_sectors = 0;
@@ -976,23 +996,24 @@ track_is_xdf(int drive, int side, int track)
if ((effective_sectors == 3) && (xdf_sectors == 3)) {
dev->current_side_flags[side] = 0x28;
return (1); /* 5.25" 2HD XDF */
return 1; /* 5.25" 2HD XDF */
}
if ((effective_sectors == 4) && (xdf_sectors == 4)) {
dev->current_side_flags[side] = 0x08;
return (2); /* 3.5" 2HD XDF */
return 2; /* 3.5" 2HD XDF */
}
}
return (0);
return 0;
}
static int
track_is_interleave(int drive, int side, int track)
{
td0_t *dev = td0[drive];
int i, effective_sectors;
int i;
int effective_sectors;
int track_spt;
effective_sectors = 0;
@@ -1003,7 +1024,7 @@ track_is_interleave(int drive, int side, int track)
track_spt = dev->track_spt[track][side];
if (track_spt != 21)
return (0);
return 0;
for (i = 0; i < track_spt; i++) {
if ((dev->sects[track][side][i].track == track) && (dev->sects[track][side][i].head == side) && (dev->sects[track][side][i].sector >= 1) && (dev->sects[track][side][i].sector <= track_spt) && (dev->sects[track][side][i].size == 2)) {
@@ -1013,18 +1034,18 @@ track_is_interleave(int drive, int side, int track)
}
if (effective_sectors == track_spt)
return (1);
return 1;
return (0);
return 0;
}
static void
td0_seek(int drive, int track)
{
td0_t *dev = td0[drive];
int side;
uint8_t id[4] = { 0, 0, 0, 0 };
int sector, current_pos;
int sector;
int current_pos;
int ssize = 512;
int track_rate = 0;
int track_gap2 = 22;
@@ -1037,7 +1058,8 @@ td0_seek(int drive, int track)
int ordered_pos = 0;
int real_sector = 0;
int actual_sector = 0;
int fm, sector_adjusted;
int fm;
int sector_adjusted;
if (dev->f == NULL)
return;
@@ -1064,7 +1086,7 @@ td0_seek(int drive, int track)
return;
}
for (side = 0; side < dev->sides; side++) {
for (int side = 0; side < dev->sides; side++) {
track_rate = dev->current_side_flags[side] & 7;
/* Make sure 300 kbps @ 360 rpm is treated the same as 250 kbps @ 300 rpm. */
if (!track_rate && (dev->current_side_flags[side] & 0x20))
@@ -1234,7 +1256,6 @@ void
td0_close(int drive)
{
td0_t *dev = td0[drive];
int i, j, k;
if (dev == NULL)
return;
@@ -1246,18 +1267,18 @@ td0_close(int drive)
if (dev->processed_buf)
free(dev->processed_buf);
for (i = 0; i < 256; i++) {
for (j = 0; j < 2; j++) {
for (k = 0; k < 256; k++)
for (uint16_t i = 0; i < 256; i++) {
for (uint8_t j = 0; j < 2; j++) {
for (uint16_t k = 0; k < 256; k++)
dev->sects[i][j][k].data = NULL;
}
}
for (i = 0; i < 256; i++) {
for (uint16_t i = 0; i < 256; i++) {
memset(dev->side_flags[i], 0, 4);
memset(dev->track_in_file[i], 0, 2);
memset(dev->calculated_gap3_lengths[i], 0, 2);
for (j = 0; j < 2; j++)
for (uint8_t j = 0; j < 2; j++)
memset(dev->sects[i][j], 0, sizeof(td0_sector_t));
}

172
src/floppy/fdi2raw.c
View File

@@ -188,7 +188,8 @@ struct node {
};
typedef struct node NODE;
static uint8_t temp, temp2;
static uint8_t temp;
static uint8_t temp2;
static uint8_t *
expand_tree(uint8_t *stream, NODE *node)
@@ -280,8 +281,9 @@ sign_extend8(uint32_t v)
static void
fdi_decode(uint8_t *stream, int size, uint8_t *out)
{
int i;
uint8_t sign_extend, sixteen_bit, sub_stream_shift;
uint8_t sign_extend;
uint8_t sixteen_bit;
uint8_t sub_stream_shift;
NODE root;
NODE *current_node;
@@ -310,7 +312,7 @@ fdi_decode(uint8_t *stream, int size, uint8_t *out)
/* sub-stream data decode */
temp2 = 0;
for (i = 0; i < size; i++) {
for (int i = 0; i < size; i++) {
uint32_t v;
uint8_t decode = 1;
current_node = &root;
@@ -462,8 +464,7 @@ bit_dedrop(FDI *fdi)
static void
byte_add(FDI *fdi, uint8_t v)
{
int i;
for (i = 7; i >= 0; i--)
for (uint8_t i = 7; i >= 0; i--)
bit_add(fdi, v & (1 << i));
}
/* add one word */
@@ -477,24 +478,21 @@ word_add(FDI *fdi, uint16_t v)
static void
byte_mfm_add(FDI *fdi, uint8_t v)
{
int i;
for (i = 7; i >= 0; i--)
for (uint8_t i = 7; i >= 0; i--)
bit_mfm_add(fdi, v & (1 << i));
}
/* add multiple bytes and mfm encode them */
static void
bytes_mfm_add(FDI *fdi, uint8_t v, int len)
{
int i;
for (i = 0; i < len; i++)
for (int i = 0; i < len; i++)
byte_mfm_add(fdi, v);
}
/* add one mfm encoded word and re-mfm encode it */
static void
word_post_mfm_add(FDI *fdi, uint16_t v)
{
int i;
for (i = 14; i >= 0; i -= 2)
for (uint8_t i = 14; i >= 0; i -= 2)
bit_mfm_add(fdi, v & (1 << i));
}
@@ -557,7 +555,8 @@ s09(FDI *fdi)
static void
s0a(FDI *fdi)
{
int i, bits = (fdi->track_src[0] << 8) | fdi->track_src[1];
int i;
int bits = (fdi->track_src[0] << 8) | fdi->track_src[1];
uint8_t b;
fdi->track_src += 2;
fdi2raw_log("s0a:bits=%d,data=%s", bits, datalog(fdi->track_src, (bits + 7) / 8));
@@ -578,7 +577,8 @@ s0a(FDI *fdi)
static void
s0b(FDI *fdi)
{
int i, bits = ((fdi->track_src[0] << 8) | fdi->track_src[1]) + 65536;
int i;
int bits = ((fdi->track_src[0] << 8) | fdi->track_src[1]) + 65536;
uint8_t b;
fdi->track_src += 2;
fdi2raw_log("s0b:bits=%d,data=%s", bits, datalog(fdi->track_src, (bits + 7) / 8));
@@ -599,7 +599,8 @@ s0b(FDI *fdi)
static void
s0c(FDI *fdi)
{
int i, bits = (fdi->track_src[0] << 8) | fdi->track_src[1];
int i;
int bits = (fdi->track_src[0] << 8) | fdi->track_src[1];
uint8_t b;
fdi->track_src += 2;
bit_drop_next(fdi);
@@ -621,7 +622,8 @@ s0c(FDI *fdi)
static void
s0d(FDI *fdi)
{
int i, bits = ((fdi->track_src[0] << 8) | fdi->track_src[1]) + 65536;
int i;
int bits = ((fdi->track_src[0] << 8) | fdi->track_src[1]) + 65536;
uint8_t b;
fdi->track_src += 2;
bit_drop_next(fdi);
@@ -854,10 +856,11 @@ static void
amiga_data(FDI *fdi, uint8_t *secbuf)
{
uint16_t mfmbuf[4 + 512];
uint32_t dodd, deven, dck;
int i;
uint32_t dodd;
uint32_t deven;
uint32_t dck;
for (i = 0; i < 512; i += 4) {
for (uint16_t i = 0; i < 512; i += 4) {
deven = ((secbuf[i + 0] << 24) | (secbuf[i + 1] << 16)
| (secbuf[i + 2] << 8) | (secbuf[i + 3]));
dodd = deven >> 1;
@@ -869,7 +872,7 @@ amiga_data(FDI *fdi, uint8_t *secbuf)
mfmbuf[(i >> 1) + 256 + 5] = (uint16_t) deven;
}
dck = 0;
for (i = 4; i < 4 + 512; i += 2)
for (uint32_t i = 4; i < 4 + 512; i += 2)
dck ^= (mfmbuf[i] << 16) | mfmbuf[i + 1];
deven = dodd = dck;
dodd >>= 1;
@@ -880,17 +883,19 @@ amiga_data(FDI *fdi, uint8_t *secbuf)
mfmbuf[2] = (uint16_t) (deven >> 16);
mfmbuf[3] = (uint16_t) deven;
for (i = 0; i < 4 + 512; i++)
for (uint32_t i = 0; i < 4 + 512; i++)
word_post_mfm_add(fdi, mfmbuf[i]);
}
static void
amiga_sector_header(FDI *fdi, uint8_t *header, uint8_t *data, int sector, int untilgap)
{
uint8_t headerbuf[4], databuf[16];
uint32_t deven, dodd, hck;
uint8_t headerbuf[4];
uint8_t databuf[16];
uint32_t deven;
uint32_t dodd;
uint32_t hck;
uint16_t mfmbuf[24];
int i;
byte_mfm_add(fdi, 0);
byte_mfm_add(fdi, 0);
@@ -918,7 +923,7 @@ amiga_sector_header(FDI *fdi, uint8_t *header, uint8_t *data, int sector, int un
mfmbuf[1] = (uint16_t) dodd;
mfmbuf[2] = (uint16_t) (deven >> 16);
mfmbuf[3] = (uint16_t) deven;
for (i = 0; i < 16; i += 4) {
for (uint8_t i = 0; i < 16; i += 4) {
deven = ((databuf[i] << 24) | (databuf[i + 1] << 16)
| (databuf[i + 2] << 8) | (databuf[i + 3]));
dodd = deven >> 1;
@@ -930,7 +935,7 @@ amiga_sector_header(FDI *fdi, uint8_t *header, uint8_t *data, int sector, int un
mfmbuf[(i >> 1) + 8 + 5] = (uint16_t) deven;
}
hck = 0;
for (i = 0; i < 4 + 16; i += 2)
for (uint32_t i = 0; i < 4 + 16; i += 2)
hck ^= (mfmbuf[i] << 16) | mfmbuf[i + 1];
deven = dodd = hck;
dodd >>= 1;
@@ -941,7 +946,7 @@ amiga_sector_header(FDI *fdi, uint8_t *header, uint8_t *data, int sector, int un
mfmbuf[22] = (uint16_t) (deven >> 16);
mfmbuf[23] = (uint16_t) deven;
for (i = 0; i < 4 + 16 + 4; i++)
for (uint32_t i = 0; i < 4 + 16 + 4; i++)
word_post_mfm_add(fdi, mfmbuf[i]);
}
@@ -1025,11 +1030,10 @@ static uint16_t
ibm_crc(uint8_t byte, int reset)
{
static uint16_t crc;
int i;
if (reset)
crc = 0xcdb4;
for (i = 0; i < 8; i++) {
for (uint8_t i = 0; i < 8; i++) {
if (crc & 0x8000) {
crc <<= 1;
if (!(byte & 0x80))
@@ -1047,7 +1051,6 @@ ibm_crc(uint8_t byte, int reset)
static void
ibm_data(FDI *fdi, uint8_t *data, uint8_t *crc, int len)
{
int i;
uint8_t crcbuf[2];
uint16_t crcv = 0;
@@ -1056,7 +1059,7 @@ ibm_data(FDI *fdi, uint8_t *data, uint8_t *crc, int len)
word_add(fdi, 0x4489);
byte_mfm_add(fdi, 0xfb);
ibm_crc(0xfb, 1);
for (i = 0; i < len; i++) {
for (int i = 0; i < len; i++) {
byte_mfm_add(fdi, data[i]);
crcv = ibm_crc(data[i], 0);
}
@@ -1075,7 +1078,6 @@ ibm_sector_header(FDI *fdi, uint8_t *data, uint8_t *crc, int secnum, int pre)
uint8_t secbuf[5];
uint8_t crcbuf[2];
uint16_t crcv;
int i;
if (pre)
bytes_mfm_add(fdi, 0, 12);
@@ -1103,7 +1105,7 @@ ibm_sector_header(FDI *fdi, uint8_t *data, uint8_t *crc, int secnum, int pre)
crcbuf[1] = (uint8_t) crcv;
}
/* data */
for (i = 0; i < 5; i++)
for (uint8_t i = 0; i < 5; i++)
byte_mfm_add(fdi, secbuf[i]);
/* crc */
byte_mfm_add(fdi, crcbuf[0]);
@@ -1263,11 +1265,9 @@ static decode_described_track_func decode_sectors_described_track[] = {
static void
track_amiga(struct fdi *fdi, int first_sector, int max_sector)
{
int i;
bit_add(fdi, 0);
bit_drop_next(fdi);
for (i = 0; i < max_sector; i++) {
for (int i = 0; i < max_sector; i++) {
amiga_sector_header(fdi, 0, 0, first_sector, max_sector - i);
amiga_data(fdi, fdi->track_src + first_sector * 512);
first_sector++;
@@ -1279,7 +1279,7 @@ track_amiga(struct fdi *fdi, int first_sector, int max_sector)
static void
track_atari_st(struct fdi *fdi, int max_sector)
{
int i, gap3 = 0;
int gap3 = 0;
uint8_t *p = fdi->track_src;
switch (max_sector) {
@@ -1291,7 +1291,7 @@ track_atari_st(struct fdi *fdi, int max_sector)
break;
}
s15(fdi);
for (i = 0; i < max_sector; i++) {
for (int i = 0; i < max_sector; i++) {
byte_mfm_add(fdi, 0x4e);
byte_mfm_add(fdi, 0x4e);
ibm_sector_header(fdi, 0, 0, fdi->current_track, 1);
@@ -1304,7 +1304,7 @@ track_atari_st(struct fdi *fdi, int max_sector)
static void
track_pc(struct fdi *fdi, int max_sector)
{
int i, gap3;
int gap3;
uint8_t *p = fdi->track_src;
switch (max_sector) {
@@ -1319,7 +1319,7 @@ track_pc(struct fdi *fdi, int max_sector)
break;
}
s11(fdi);
for (i = 0; i < max_sector; i++) {
for (int i = 0; i < max_sector; i++) {
byte_mfm_add(fdi, 0x4e);
byte_mfm_add(fdi, 0x4e);
ibm_sector_header(fdi, 0, 0, fdi->current_track, 1);
@@ -1402,9 +1402,15 @@ static decode_normal_track_func decode_normal_track[] = {
static void
fix_mfm_sync(FDI *fdi)
{
int i, pos, off1, off2, off3, mask1, mask2, mask3;
int pos;
int off1;
int off2;
int off3;
int mask1;
int mask2;
int mask3;
for (i = 0; i < fdi->mfmsync_offset; i++) {
for (int i = 0; i < fdi->mfmsync_offset; i++) {
pos = fdi->mfmsync_buffer[i];
off1 = (pos - 1) >> 3;
off2 = (pos + 1) >> 3;
@@ -1464,7 +1470,7 @@ fdi_decompress(int pulses, uint8_t *sizep, uint8_t *src, int *dofree)
uint32_t *dst2;
int len = size & 0x3fffff;
uint8_t *dst;
int mode = size >> 22, i;
int mode = size >> 22;
*dofree = 0;
if (mode == 0 && pulses * 2 > len)
@@ -1472,7 +1478,7 @@ fdi_decompress(int pulses, uint8_t *sizep, uint8_t *src, int *dofree)
if (mode == 0) {
dst2 = (uint32_t *) src;
dst = src;
for (i = 0; i < pulses; i++) {
for (int i = 0; i < pulses; i++) {
*dst2++ = get_u32(src);
src += 4;
}
@@ -1526,9 +1532,7 @@ static int totaldiv;
static void
init_array(uint32_t standard_MFM_2_bit_cell_size, int nb_of_bits)
{
int i;
for (i = 0; i < FDI_MAX_ARRAY; i++) {
for (uint8_t i = 0; i < FDI_MAX_ARRAY; i++) {
psarray[i].size = standard_MFM_2_bit_cell_size; /* That is (total track length / 50000) for Amiga double density */
total += psarray[i].size;
psarray[i].number_of_bits = nb_of_bits;
@@ -1672,11 +1676,18 @@ fdi2_decode(FDI *fdi, uint32_t totalavg, uint32_t *avgp, uint32_t *minp, uint32_
uint32_t adjusted_pulse;
uint32_t standard_MFM_2_bit_cell_size = totalavg / 50000;
uint32_t standard_MFM_8_bit_cell_size = totalavg / 12500;
int real_size, i, j, nexti, eodat, outstep, randval;
int real_size;
int i;
int j;
int nexti;
int eodat;
int outstep;
int randval;
int indexoffset = *indexoffsetp;
uint8_t *d = fdi->track_dst_buffer;
uint16_t *pt = fdi->track_dst_buffer_timing;
uint32_t ref_pulse, pulse;
uint32_t ref_pulse;
uint32_t pulse;
int32_t jitter;
/* detects a long-enough stable pulse coming just after another stable pulse */
@@ -1714,7 +1725,9 @@ fdi2_decode(FDI *fdi, uint32_t totalavg, uint32_t *avgp, uint32_t *minp, uint32_
/* gets the next long-enough pulse (this may require more than one pulse) */
pulse = 0;
while (pulse < ((avg_size / 4) - (avg_size / 16))) {
uint32_t avg_pulse, min_pulse, max_pulse;
uint32_t avg_pulse;
uint32_t min_pulse;
uint32_t max_pulse;
i++;
if (i >= pulses)
i = 0;
@@ -1742,7 +1755,7 @@ fdi2_decode(FDI *fdi, uint32_t totalavg, uint32_t *avgp, uint32_t *minp, uint32_
randval = rand();
if (randval < (RAND_MAX / 2)) {
if (randval > (RAND_MAX / 4)) {
if (randval <= (((3LL * (uint64_t) RAND_MAX) / 8)))
if (randval <= ((3LL * (uint64_t) RAND_MAX) / 8))
randval = (2 * randval) - (RAND_MAX / 4);
else
randval = (4 * randval) - RAND_MAX;
@@ -1751,7 +1764,7 @@ fdi2_decode(FDI *fdi, uint32_t totalavg, uint32_t *avgp, uint32_t *minp, uint32_
} else {
randval -= RAND_MAX / 2;
if (randval > (RAND_MAX / 4)) {
if (randval <= (((3LL * (uint64_t) RAND_MAX) / 8)))
if (randval <= ((3LL * (uint64_t) RAND_MAX) / 8))
randval = (2 * randval) - (RAND_MAX / 4);
else
randval = (4 * randval) - RAND_MAX;
@@ -1777,7 +1790,7 @@ fdi2_decode(FDI *fdi, uint32_t totalavg, uint32_t *avgp, uint32_t *minp, uint32_
randval = rand();
if (randval < (RAND_MAX / 2)) {
if (randval > (RAND_MAX / 4)) {
if (randval <= (((3LL * (uint64_t) RAND_MAX) / 8)))
if (randval <= ((3LL * (uint64_t) RAND_MAX) / 8))
randval = (2 * randval) - (RAND_MAX / 4);
else
randval = (4 * randval) - RAND_MAX;
@@ -1786,7 +1799,7 @@ fdi2_decode(FDI *fdi, uint32_t totalavg, uint32_t *avgp, uint32_t *minp, uint32_
} else {
randval -= RAND_MAX / 2;
if (randval > (RAND_MAX / 4)) {
if (randval <= (((3LL * (uint64_t) RAND_MAX) / 8)))
if (randval <= ((3LL * (uint64_t) RAND_MAX) / 8))
randval = (2 * randval) - (RAND_MAX / 4);
else
randval = (4 * randval) - RAND_MAX;
@@ -1899,14 +1912,14 @@ 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, *pt;
uint16_t *pt2;
uint16_t *pt;
double avg_bit_len;
int i;
avg_bit_len = (double) totalavg / (double) bitoffset;
pt2 = fdi->track_dst_buffer_timing;
pt = out;
for (i = 0; i < bitoffset / 8; i++) {
for (int i = 0; i < bitoffset / 8; i++) {
double v = (pt2[0] + pt2[1] + pt2[2] + pt2[3] + pt2[4] + pt2[5] + pt2[6] + pt2[7]) / 8.0;
v = 1000.0 * v / avg_bit_len;
*pt++ = (uint16_t) v;
@@ -1921,12 +1934,25 @@ decode_lowlevel_track(FDI *fdi, int track, struct fdi_cache *cache)
{
uint8_t *p1;
uint32_t *p2;
uint32_t *avgp, *minp = 0, *maxp = 0;
uint32_t *avgp;
uint32_t *minp = 0;
uint32_t *maxp = 0;
uint8_t *idxp = 0;
uint32_t maxidx, totalavg, weakbits;
int i, j, len, pulses, indexoffset;
int avg_free, min_free = 0, max_free = 0, idx_free;
int idx_off1 = 0, idx_off2 = 0, idx_off3 = 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;
p1 = fdi->track_src;
pulses = get_u32(p1);
@@ -2056,13 +2082,11 @@ static int bit_rate_table[16] = { 125, 150, 250, 300, 500, 1000 };
void
fdi2raw_header_free(FDI *fdi)
{
int i;
fdi_free(fdi->mfmsync_buffer);
fdi_free(fdi->track_src_buffer);
fdi_free(fdi->track_dst_buffer);
fdi_free(fdi->track_dst_buffer_timing);
for (i = 0; i < MAX_TRACKS; i++) {
for (uint8_t i = 0; i < MAX_TRACKS; i++) {
struct fdi_cache *c = &fdi->cache[i];
if (c->idx_free)
fdi_free(c->idxp);
@@ -2130,8 +2154,11 @@ fdi2raw_get_tpi(FDI *fdi)
FDI *
fdi2raw_header(FILE *f)
{
long i, offset, oldseek;
uint8_t type, size;
long i;
long offset;
long oldseek;
uint8_t type;
uint8_t size;
FDI *fdi;
fdi2raw_log("ALLOC: memory allocated %d\n", fdi_allocated);
@@ -2204,7 +2231,8 @@ static int
fdi2raw_loadrevolution_2(FDI *fdi, uint16_t *mfmbuf, uint16_t *tracktiming, int track, int *tracklength, int *indexoffsetp, int *multirev, int mfm)
{
struct fdi_cache *cache = &fdi->cache[track];
int len, i, idx;
int len;
int idx;
memset(fdi->track_dst_buffer, 0, MAX_DST_BUFFER);
idx = cache->indexoffset;
@@ -2218,7 +2246,7 @@ fdi2raw_loadrevolution_2(FDI *fdi, uint16_t *mfmbuf, uint16_t *tracktiming, int
*multirev = 1;
*tracklength = len;
for (i = 0; i < (len + 15) / (2 * 8); i++) {
for (int i = 0; i < (len + 15) / (2 * 8); i++) {
uint8_t *data = fdi->track_dst_buffer + i * 2;
*mfmbuf++ = 256 * *data + *(data + 1);
}
@@ -2239,7 +2267,7 @@ int
fdi2raw_loadtrack(FDI *fdi, uint16_t *mfmbuf, uint16_t *tracktiming, int track, int *tracklength, int *indexoffsetp, int *multirev, int mfm)
{
uint8_t *p;
int outlen, i;
int outlen;
struct fdi_cache *cache = &fdi->cache[track];
track ^= fdi->reversed_side;
@@ -2285,7 +2313,7 @@ fdi2raw_loadtrack(FDI *fdi, uint16_t *mfmbuf, uint16_t *tracktiming, int track,
outlen = handle_sectors_described_track(fdi);
} else if ((fdi->track_type & 0xf0)) {
} else if (fdi->track_type & 0xf0) {
zxx(fdi);
outlen = -1;
@@ -2309,7 +2337,7 @@ fdi2raw_loadtrack(FDI *fdi, uint16_t *mfmbuf, uint16_t *tracktiming, int track,
if (cache->lowlevel)
return fdi2raw_loadrevolution_2(fdi, mfmbuf, tracktiming, track, tracklength, indexoffsetp, multirev, mfm);
*tracklength = fdi->out;
for (i = 0; i < ((*tracklength) + 15) / (2 * 8); i++) {
for (int i = 0; i < ((*tracklength) + 15) / (2 * 8); i++) {
uint8_t *data = fdi->track_dst_buffer + i * 2;
*mfmbuf++ = 256 * *data + *(data + 1);
}

2
src/mem/i2c_eeprom.c
View File

@@ -117,7 +117,7 @@ uint8_t
log2i(uint32_t i)
{
uint8_t ret = 0;
while ((i >>= 1))
while (i >>= 1)
ret++;
return ret;
}

7
src/mem/intel_flash.c
View File

@@ -282,8 +282,9 @@ flash_writel(uint32_t addr, uint32_t val, void *p)
static void
intel_flash_add_mappings(flash_t *dev)
{
int max = 2, i = 0;
uint32_t base, fbase;
int max = 2;
uint32_t base;
uint32_t fbase;
uint32_t sub = 0x20000;
if (biosmask == 0x7ffff) {
@@ -294,7 +295,7 @@ intel_flash_add_mappings(flash_t *dev)
max = 4;
}
for (i = 0; i < max; i++) {
for (int i = 0; i < max; i++) {
if (biosmask == 0x7ffff)
base = 0x80000 + (i << 16);
else if (biosmask == 0x3ffff)

47
src/mem/rom.c
View File

@@ -90,12 +90,11 @@ FILE *
rom_fopen(const char *fn, char *mode)
{
char temp[1024];
rom_path_t *rom_path;
FILE *fp = NULL;
if (strstr(fn, "roms/") == fn) {
/* Relative path */
for (rom_path = &rom_paths; rom_path != NULL; rom_path = rom_path->next) {
for (rom_path_t *rom_path = &rom_paths; rom_path != NULL; rom_path = rom_path->next) {
path_append_filename(temp, rom_path->path, fn + 5);
if ((fp = plat_fopen(temp, mode)) != NULL) {
@@ -114,11 +113,10 @@ int
rom_getfile(char *fn, char *s, int size)
{
char temp[1024];
rom_path_t *rom_path;
if (strstr(fn, "roms/") == fn) {
/* Relative path */
for (rom_path = &rom_paths; rom_path != NULL; rom_path = rom_path->next) {
for (rom_path_t *rom_path = &rom_paths; rom_path != NULL; rom_path = rom_path->next) {
path_append_filename(temp, rom_path->path, fn + 5);
if (rom_present(temp)) {
@@ -147,10 +145,10 @@ rom_present(char *fn)
f = rom_fopen(fn, "rb");
if (f != NULL) {
(void) fclose(f);
return (1);
return 1;
}
return (0);
return 0;
}
uint8_t
@@ -212,7 +210,7 @@ rom_load_linear_oddeven(const char *fn, uint32_t addr, int sz, int off, uint8_t
if (f == NULL) {
rom_log("ROM: image '%s' not found\n", fn);
return (0);
return 0;
}
/* Make sure we only look at the base-256K offset. */
@@ -236,7 +234,7 @@ rom_load_linear_oddeven(const char *fn, uint32_t addr, int sz, int off, uint8_t
(void) fclose(f);
return (1);
return 1;
}
/* Load a ROM BIOS from its chips, interleaved mode. */
@@ -247,7 +245,7 @@ rom_load_linear(const char *fn, uint32_t addr, int sz, int off, uint8_t *ptr)
if (f == NULL) {
rom_log("ROM: image '%s' not found\n", fn);
return (0);
return 0;
}
/* Make sure we only look at the base-256K offset. */
@@ -265,7 +263,7 @@ rom_load_linear(const char *fn, uint32_t addr, int sz, int off, uint8_t *ptr)
(void) fclose(f);
return (1);
return 1;
}
/* Load a ROM BIOS from its chips, linear mode with high bit flipped. */
@@ -276,7 +274,7 @@ rom_load_linear_inverted(const char *fn, uint32_t addr, int sz, int off, uint8_t
if (f == NULL) {
rom_log("ROM: image '%s' not found\n", fn);
return (0);
return 0;
}
/* Make sure we only look at the base-256K offset. */
@@ -289,7 +287,7 @@ rom_load_linear_inverted(const char *fn, uint32_t addr, int sz, int off, uint8_t
(void) fseek(f, 0, SEEK_END);
if (ftell(f) < sz) {
(void) fclose(f);
return (0);
return 0;
}
if (ptr != NULL) {
@@ -303,7 +301,7 @@ rom_load_linear_inverted(const char *fn, uint32_t addr, int sz, int off, uint8_t
(void) fclose(f);
return (1);
return 1;
}
/* Load a ROM BIOS from its chips, interleaved mode. */
@@ -312,7 +310,6 @@ rom_load_interleaved(const char *fnl, const char *fnh, uint32_t addr, int sz, in
{
FILE *fl = rom_fopen(fnl, "rb");
FILE *fh = rom_fopen(fnh, "rb");
int c;
if (fl == NULL || fh == NULL) {
if (fl == NULL)
@@ -324,7 +321,7 @@ rom_load_interleaved(const char *fnl, const char *fnh, uint32_t addr, int sz, in
else
(void) fclose(fh);
return (0);
return 0;
}
/* Make sure we only look at the base-256K offset. */
@@ -337,7 +334,7 @@ rom_load_interleaved(const char *fnl, const char *fnh, uint32_t addr, int sz, in
if (ptr != NULL) {
(void) fseek(fl, off, SEEK_SET);
(void) fseek(fh, off, SEEK_SET);
for (c = 0; c < sz; c += 2) {
for (int c = 0; c < sz; c += 2) {
ptr[addr + c] = fgetc(fl) & 0xff;
ptr[addr + c + 1] = fgetc(fh) & 0xff;
}
@@ -346,7 +343,7 @@ rom_load_interleaved(const char *fnl, const char *fnh, uint32_t addr, int sz, in
(void) fclose(fh);
(void) fclose(fl);
return (1);
return 1;
}
static int
@@ -428,8 +425,10 @@ bios_readl(uint32_t addr, void *priv)
static void
bios_add(void)
{
int temp_cpu_type, temp_cpu_16bitbus = 1;
int temp_is286 = 0, temp_is6117 = 0;
int temp_cpu_type;
int temp_cpu_16bitbus = 1;
int temp_is286 = 0;
int temp_is6117 = 0;
if (/*AT && */ cpu_s) {
temp_cpu_type = cpu_s->cpu_type;
@@ -482,7 +481,7 @@ bios_load(const char *fn1, const char *fn2, uint32_t addr, int sz, int off, int
{
uint8_t ret = 0;
uint8_t *ptr = NULL;
int i, old_sz = sz;
int old_sz = sz;
/*
f0000, 65536 = prepare 64k rom starting at f0000, load 64k bios at 0000
@@ -512,7 +511,7 @@ bios_load(const char *fn1, const char *fn2, uint32_t addr, int sz, int off, int
if (!bios_only && (flags & FLAG_REP) && (old_sz >= 65536) && (sz < old_sz)) {
old_sz /= sz;
for (i = 0; i < (old_sz - 1); i++) {
for (int i = 0; i < (old_sz - 1); i++) {
rom_log("Copying ptr[%08X] to ptr[%08X]\n", addr - biosaddr, i * sz);
memcpy(&(ptr[i * sz]), &(ptr[addr - biosaddr]), sz);
}
@@ -591,7 +590,7 @@ rom_init(rom_t *rom, const char *fn, uint32_t addr, int sz, int mask, int off, u
NULL, NULL, NULL,
rom->rom, flags | MEM_MAPPING_ROM_WS, rom);
return (0);
return 0;
}
int
@@ -620,7 +619,7 @@ rom_init_oddeven(rom_t *rom, const char *fn, uint32_t addr, int sz, int mask, in
NULL, NULL, NULL,
rom->rom, flags | MEM_MAPPING_ROM_WS, rom);
return (0);
return 0;
}
int
@@ -647,5 +646,5 @@ rom_init_interleaved(rom_t *rom, const char *fnl, const char *fnh, uint32_t addr
NULL, NULL, NULL,
rom->rom, flags | MEM_MAPPING_ROM_WS, rom);
return (0);
return 0;
}

14
src/mem/smram.c
View File

@@ -29,7 +29,8 @@
#include <86box/mem.h>
#include <86box/smram.h>
static smram_t *base_smram, *last_smram;
static smram_t *base_smram;
static smram_t *last_smram;
static uint8_t use_separate_smram = 0;
static uint8_t smram[0x40000];
@@ -135,7 +136,8 @@ smram_writel(uint32_t addr, uint32_t val, void *priv)
void
smram_backup_all(void)
{
smram_t *temp_smram = base_smram, *next;
smram_t *temp_smram = base_smram;
smram_t *next;
while (temp_smram != NULL) {
temp_smram->old_host_base = temp_smram->host_base;
@@ -150,7 +152,8 @@ smram_backup_all(void)
void
smram_recalc_all(int ret)
{
smram_t *temp_smram = base_smram, *next;
smram_t *temp_smram = base_smram;
smram_t *next;
if (base_smram == NULL)
return;
@@ -316,7 +319,8 @@ smram_disable(smram_t *smr)
void
smram_disable_all(void)
{
smram_t *temp_smram = base_smram, *next;
smram_t *temp_smram = base_smram;
smram_t *next;
while (temp_smram != NULL) {
smram_disable(temp_smram);
@@ -339,7 +343,7 @@ smram_enable_ex(smram_t *smr, uint32_t host_base, uint32_t ram_base, uint32_t si
if ((size != 0x00000000) && (flags_normal || flags_smm)) {
smr->host_base = host_base;
smr->ram_base = ram_base,
smr->ram_base = ram_base;
smr->size = size;
mem_mapping_set_addr(&(smr->mapping), smr->host_base, smr->size);

43
src/mem/spd.c
View File

@@ -92,7 +92,9 @@ comp_ui16_rev(const void *elem1, const void *elem2)
void
spd_populate(uint16_t *rows, uint8_t slot_count, uint16_t total_size, uint16_t min_module_size, uint16_t max_module_size, uint8_t enable_asym)
{
uint8_t row, next_empty_row, split, i;
uint8_t row;
uint8_t next_empty_row;
uint8_t split;
uint16_t asym;
/* Populate rows with modules in power-of-2 capacities. */
@@ -138,7 +140,7 @@ spd_populate(uint16_t *rows, uint8_t slot_count, uint16_t total_size, uint16_t m
/* Find next empty row. */
next_empty_row = 0;
for (i = row + 1; i < slot_count && !next_empty_row; i++) {
for (uint8_t i = row + 1; i < slot_count && !next_empty_row; i++) {
if (!rows[i])
next_empty_row = i;
}
@@ -176,8 +178,13 @@ spd_write_part_no(char *part_no, char *type, uint16_t size)
void
spd_register(uint8_t ram_type, uint8_t slot_mask, uint16_t max_module_size)
{
uint8_t slot, slot_count, row, i;
uint16_t min_module_size, rows[SPD_MAX_SLOTS], asym;
uint8_t slot;
uint8_t slot_count;
uint8_t row;
uint8_t i;
uint16_t min_module_size;
uint16_t rows[SPD_MAX_SLOTS];
uint16_t asym;
spd_edo_t *edo_data;
spd_sdram_t *sdram_data;
@@ -336,8 +343,11 @@ spd_register(uint8_t ram_type, uint8_t slot_mask, uint16_t max_module_size)
void
spd_write_drbs(uint8_t *regs, uint8_t reg_min, uint8_t reg_max, uint8_t drb_unit)
{
uint8_t row, dimm, drb, apollo = 0;
uint16_t size, rows[SPD_MAX_SLOTS];
uint8_t dimm;
uint8_t drb;
uint8_t apollo = 0;
uint16_t size;
uint16_t rows[SPD_MAX_SLOTS];
/* Special case for VIA Apollo Pro family, which jumps from 5F to 56. */
if (reg_max < reg_min) {
@@ -353,7 +363,7 @@ spd_write_drbs(uint8_t *regs, uint8_t reg_min, uint8_t reg_max, uint8_t drb_unit
/* Write DRBs for each row. */
spd_log("SPD: Writing DRBs... regs=[%02X:%02X] unit=%d\n", reg_min, reg_max, drb_unit);
for (row = 0; row <= (reg_max - reg_min); row++) {
for (uint8_t row = 0; row <= (reg_max - reg_min); row++) {
dimm = (row >> 1);
size = 0;
@@ -392,8 +402,11 @@ spd_write_drbs(uint8_t *regs, uint8_t reg_min, uint8_t reg_max, uint8_t drb_unit
void
spd_write_drbs_with_ext(uint8_t *regs, uint8_t reg_min, uint8_t reg_max, uint8_t drb_unit)
{
uint8_t row, dimm, drb;
uint16_t size, row_val = 0, rows[SPD_MAX_SLOTS];
uint8_t dimm;
uint8_t drb;
uint16_t size;
uint16_t row_val = 0;
uint16_t rows[SPD_MAX_SLOTS];
int shift;
/* No SPD: split SIMMs into pairs as if they were "DIMM"s. */
@@ -404,7 +417,7 @@ spd_write_drbs_with_ext(uint8_t *regs, uint8_t reg_min, uint8_t reg_max, uint8_t
/* Write DRBs for each row. */
spd_log("SPD: Writing DRBs... regs=[%02X:%02X] unit=%d\n", reg_min, reg_max, drb_unit);
for (row = 0; row <= (reg_max - reg_min); row++) {
for (uint8_t row = 0; row <= (reg_max - reg_min); row++) {
dimm = (row >> 1);
size = 0;
@@ -441,9 +454,10 @@ spd_write_drbs_with_ext(uint8_t *regs, uint8_t reg_min, uint8_t reg_max, uint8_t
void
spd_write_drbs_interleaved(uint8_t *regs, uint8_t reg_min, uint8_t reg_max, uint8_t drb_unit)
{
uint8_t row, dimm;
uint8_t dimm;
uint8_t drb;
uint16_t size, size_acc = 0;
uint16_t size;
uint16_t size_acc = 0;
uint16_t rows[SPD_MAX_SLOTS];
/* No SPD: split SIMMs into pairs as if they were "DIMM"s. */
@@ -454,7 +468,7 @@ spd_write_drbs_interleaved(uint8_t *regs, uint8_t reg_min, uint8_t reg_max, uint
/* Write DRBs for each row. */
spd_log("SPD: Writing DRBs... regs=[%02X:%02X] unit=%d\n", reg_min, reg_max, drb_unit);
for (row = 0; row <= (reg_max - reg_min); row += 2) {
for (uint8_t row = 0; row <= (reg_max - reg_min); row += 2) {
dimm = (row >> 2);
size = 0;
@@ -493,7 +507,8 @@ spd_write_drbs_interleaved(uint8_t *regs, uint8_t reg_min, uint8_t reg_max, uint
void
spd_write_drbs_ali1621(uint8_t *regs, uint8_t reg_min, uint8_t reg_max)
{
uint8_t dimm, drb;
uint8_t dimm;
uint8_t drb;
uint16_t size;
uint16_t rows[SPD_MAX_SLOTS];

17
src/mem/sst_flash.c
View File

@@ -89,7 +89,7 @@ static char flash_path[1024];
#define SST39LF080 0xd800
#define SST39LF016 0xd900
/*
#if 0
// 16 wide
#define SST39WF400 0x272f
#define SST39WF400B 0x272e
@@ -103,7 +103,7 @@ static char flash_path[1024];
#define SST39LF400 0x2780
#define SST39LF800 0x2781
#define SST39LF160 0x2782
*/
#endif
#define SST49LF002 0x5700
#define SST49LF020 0x6100
@@ -150,7 +150,8 @@ sst_sector_erase(sst_t *dev, uint32_t addr)
static void
sst_new_command(sst_t *dev, uint32_t addr, uint8_t val)
{
uint32_t base = 0x00000, size = dev->size;
uint32_t base = 0x00000;
uint32_t size = dev->size;
if (dev->command_state == 5)
switch (val) {
@@ -230,11 +231,10 @@ static void
sst_page_write(void *priv)
{
sst_t *dev = (sst_t *) priv;
int i;
if (dev->last_addr != 0xffffffff) {
dev->page_base = dev->last_addr & dev->page_mask;
for (i = 0; i < 128; i++) {
for (uint8_t i = 0; i < 128; i++) {
if (dev->page_dirty[i]) {
if (((dev->page_base + i) < 0x2000) && (dev->bbp_first_8k & 0x01))
continue;
@@ -419,14 +419,15 @@ sst_readl(uint32_t addr, void *p)
static void
sst_add_mappings(sst_t *dev)
{
int i = 0, count;
uint32_t base, fbase;
int count;
uint32_t base;
uint32_t fbase;
uint32_t root_base;
count = dev->size >> 16;
root_base = 0x100000 - dev->size;
for (i = 0; i < count; i++) {
for (int i = 0; i < count; i++) {
base = root_base + (i << 16);
fbase = base & biosmask;

9
src/printer/png.c
View File

@@ -110,7 +110,6 @@ png_write_gray(char *fn, int inv, uint8_t *pix, int16_t w, int16_t h)
png_structp png = NULL;
png_infop info = NULL;
png_bytep row;
int16_t x, y;
FILE *fp;
/* Create the image file. */
@@ -127,7 +126,7 @@ error:
(&png, &info);
if (fp != NULL)
(void) fclose(fp);
return (0);
return 0;
}
/* Initialize PNG stuff. */
@@ -159,8 +158,8 @@ error:
row = (png_bytep) malloc(PNGFUNC(get_rowbytes)(png, info));
/* Process all scanlines in the image. */
for (y = 0; y < h; y++) {
for (x = 0; x < w; x++) {
for (int16_t y = 0; y < h; y++) {
for (int16_t x = 0; x < w; x++) {
/* Copy the pixel data. */
if (inv)
row[x] = 255 - pix[(y * w) + x];
@@ -185,7 +184,7 @@ error:
/* Clean up. */
(void) fclose(fp);
return (1);
return 1;
}
/* Write the given BITMAP-format image as an 8-bit RGBA PNG image file. */

46
src/printer/prt_escp.c
View File

@@ -442,7 +442,6 @@ static void
fill_palette(uint8_t redmax, uint8_t greenmax, uint8_t bluemax, uint8_t colorID, escp_t *dev)
{
uint8_t colormask;
int i;
double red = (double) redmax / (double) 30.9;
double green = (double) greenmax / (double) 30.9;
@@ -450,7 +449,7 @@ fill_palette(uint8_t redmax, uint8_t greenmax, uint8_t bluemax, uint8_t colorID,
colormask = colorID <<= 5;
for (i = 0; i < 32; i++) {
for (uint8_t i = 0; i < 32; i++) {
dev->palcol[i + colormask].r = 255 - (uint8_t) floor(red * (double) i);
dev->palcol[i + colormask].g = 255 - (uint8_t) floor(green * (double) i);
dev->palcol[i + colormask].b = 255 - (uint8_t) floor(blue * (double) i);
@@ -460,8 +459,6 @@ fill_palette(uint8_t redmax, uint8_t greenmax, uint8_t bluemax, uint8_t colorID,
static void
reset_printer(escp_t *dev)
{
int i;
/* TODO: these should be configurable. */
dev->color = COLOR_BLACK;
dev->curr_x = dev->curr_y = 0.0;
@@ -501,7 +498,7 @@ reset_printer(escp_t *dev)
new_page(dev, 0, 1);
for (i = 0; i < 32; i++)
for (uint8_t i = 0; i < 32; i++)
dev->horizontal_tabs[i] = i * 8.0 * (1.0 / dev->cpi);
dev->num_horizontal_tabs = 32;
dev->num_vertical_tabs = -1;
@@ -646,11 +643,13 @@ update_font(escp_t *dev)
static int
process_char(escp_t *dev, uint8_t ch)
{
double new_x, new_y;
double new_x;
double new_y;
double move_to;
double unit_size;
double reverse;
double new_top, new_bottom;
double new_top;
double new_bottom;
uint16_t rel_move;
int16_t i;
@@ -1573,8 +1572,10 @@ static void
handle_char(escp_t *dev, uint8_t ch)
{
FT_UInt char_index;
uint16_t pen_x, pen_y;
uint16_t line_start, line_y;
uint16_t pen_x;
uint16_t pen_y;
uint16_t line_start;
uint16_t line_y;
double x_advance;
if (dev->page == NULL)
@@ -1689,15 +1690,15 @@ static void
blit_glyph(escp_t *dev, unsigned destx, unsigned desty, int8_t add)
{
FT_Bitmap *bitmap = &dev->fontface->glyph->bitmap;
unsigned x, y;
uint8_t src, *dst;
uint8_t src;
uint8_t *dst;
/* check if freetype is available */
if (ft_lib == NULL)
return;
for (y = 0; y < bitmap->rows; y++) {
for (x = 0; x < bitmap->width; x++) {
for (unsigned int y = 0; y < bitmap->rows; y++) {
for (unsigned int x = 0; x < bitmap->width; x++) {
src = *(bitmap->buffer + x + y * bitmap->pitch);
/* ignore background, and respect page size */
if (src > 0 && (destx + x < (unsigned) dev->page->w) && (desty + y < (unsigned) dev->page->h)) {
@@ -1724,9 +1725,8 @@ draw_hline(escp_t *dev, unsigned from_x, unsigned to_x, unsigned y, int8_t broke
{
unsigned breakmod = dev->dpi / 15;
unsigned gapstart = (breakmod * 4) / 5;
unsigned x;
for (x = from_x; x <= to_x; x++) {
for (unsigned int x = from_x; x <= to_x; x++) {
/* Skip parts if broken line or going over the border. */
if ((!broken || (x % breakmod <= gapstart)) && (x < dev->page->w)) {
if (y > 0 && (y - 1) < dev->page->h)
@@ -1856,7 +1856,6 @@ print_bit_graph(escp_t *dev, uint8_t ch)
{
uint8_t pixel_w; /* width of the "pixel" */
uint8_t pixel_h; /* height of the "pixel" */
unsigned i, j, xx, yy;
double old_y;
dev->bg_column[dev->bg_bytes_read++] = ch;
@@ -1877,14 +1876,14 @@ print_bit_graph(escp_t *dev, uint8_t ch)
pixel_h = dev->dpi / dev->bg_v_density > 0 ? dev->dpi / dev->bg_v_density : 1;
}
for (i = 0; i < dev->bg_bytes_per_column; i++) {
for (uint8_t i = 0; i < dev->bg_bytes_per_column; i++) {
/* for each byte */
for (j = 128; j != 0; j >>= 1) {
for (uint8_t j = 128; j != 0; j >>= 1) {
/* for each bit */
if (dev->bg_column[i] & j) {
/* draw a "pixel" */
for (xx = 0; xx < pixel_w; xx++) {
for (yy = 0; yy < pixel_h; yy++) {
for (uint8_t xx = 0; xx < pixel_w; xx++) {
for (uint8_t yy = 0; yy < pixel_h; yy++) {
if (((PIXX + xx) < (unsigned) dev->page->w) && ((PIXY + yy) < (unsigned) dev->page->h))
*((uint8_t *) dev->page->pixels + (PIXX + xx) + (PIXY + yy) * dev->page->pitch) |= (dev->color | 0x1f);
}
@@ -1983,7 +1982,7 @@ read_status(void *priv)
if (!dev->ack)
ret |= 0x40;
return (ret);
return ret;
}
static void *
@@ -1991,7 +1990,6 @@ escp_init(void *lpt)
{
const char *fn = PATH_FREETYPE_DLL;
escp_t *dev;
int i;
/* Dynamically load FreeType. */
if (ft_handle == NULL) {
@@ -2047,7 +2045,7 @@ escp_init(void *lpt)
memset(dev->page->pixels, 0x00, (size_t) dev->page->pitch * dev->page->h);
/* Initialize parameters. */
for (i = 0; i < 32; i++) {
for (uint8_t i = 0; i < 32; i++) {
dev->palcol[i].r = 255;
dev->palcol[i].g = 255;
dev->palcol[i].b = 255;
@@ -2082,7 +2080,7 @@ escp_init(void *lpt)
timer_add(&dev->pulse_timer, pulse_timer, dev, 0);
timer_add(&dev->timeout_timer, timeout_timer, dev, 0);
return (dev);
return dev;
}
static void

8
src/printer/prt_ps.c
View File

@@ -143,7 +143,9 @@ convert_to_pdf(ps_t *dev)
{
volatile int code;
void *instance = NULL;
char input_fn[1024], output_fn[1024], *gsargv[9];
char input_fn[1024];
char output_fn[1024];
char *gsargv[9];
strcpy(input_fn, dev->printer_path);
path_slash(input_fn);
@@ -323,7 +325,7 @@ ps_read_status(void *p)
if (!dev->ack)
ret |= 0x40;
return (ret);
return ret;
}
static void *
@@ -362,7 +364,7 @@ ps_init(void *lpt)
reset_ps(dev);
return (dev);
return dev;
}
static void

11
src/printer/prt_text.c
View File

@@ -138,7 +138,6 @@ static void
dump_page(prnt_t *dev)
{
char path[1024];
uint16_t x, y;
uint8_t ch;
FILE *fp;
@@ -162,8 +161,8 @@ dump_page(prnt_t *dev)
if (ftell(fp) != 0)
fputc('\014', fp);
for (y = 0; y < dev->curr_y; y++) {
for (x = 0; x < dev->page->w; x++) {
for (uint16_t y = 0; y < dev->curr_y; y++) {
for (uint16_t x = 0; x < dev->page->w; x++) {
ch = dev->page->chars[(y * dev->page->w) + x];
if (ch == 0x00) {
/* End of line marker. */
@@ -329,7 +328,7 @@ process_char(prnt_t *dev, uint8_t ch)
}
/* Just a printable character. */
return (0);
return 0;
}
static void
@@ -416,7 +415,7 @@ read_status(void *priv)
if (!dev->ack)
ret |= 0x40;
return (ret);
return ret;
}
static void *
@@ -443,7 +442,7 @@ prnt_init(void *lpt)
timer_add(&dev->pulse_timer, pulse_timer, dev, 0);
timer_add(&dev->timeout_timer, timeout_timer, dev, 0);
return (dev);
return dev;
}
static void