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

clang-format in src/floppy/

Browse Source
This commit is contained in:
Jasmine Iwanek
2022-09-18 17:14:15 -04:00
parent 696f6f7e2f
commit 58d86a0739
11 changed files with 6570 additions and 6752 deletions
Download Patch File Download Diff File Expand all files Collapse all files

140
src/floppy/fdc.c
View File

@@ -37,10 +37,8 @@
#include <86box/fdc.h> #include <86box/fdc.h>
#include <86box/fdc_ext.h> #include <86box/fdc_ext.h>
extern uint64_t motoron[FDD_NUM]; extern uint64_t motoron[FDD_NUM];
const uint8_t command_has_drivesel[32] = { const uint8_t command_has_drivesel[32] = {
0, 0, 0, 0,
1, /* READ TRACK */ 1, /* READ TRACK */
@@ -68,7 +66,6 @@ const uint8_t command_has_drivesel[32] = {
0, 0 0, 0
}; };
static uint8_t current_drive = 0; static uint8_t current_drive = 0;
static void fdc_callback(void *priv); static void fdc_callback(void *priv);
@@ -77,20 +74,17 @@ int lastbyte=0;
int floppymodified[4]; int floppymodified[4];
int floppyrate[4]; int floppyrate[4];
int fdc_type = 0; int fdc_type = 0;
#ifdef ENABLE_FDC_LOG #ifdef ENABLE_FDC_LOG
int fdc_do_log = ENABLE_FDC_LOG; int fdc_do_log = ENABLE_FDC_LOG;
static void static void
fdc_log(const char *fmt, ...) fdc_log(const char *fmt, ...)
{ {
va_list ap; va_list ap;
if (fdc_do_log) if (fdc_do_log) {
{
va_start(ap, fmt); va_start(ap, fmt);
pclog_ex(fmt, ap); pclog_ex(fmt, ap);
va_end(ap); va_end(ap);
@@ -100,7 +94,6 @@ fdc_log(const char *fmt, ...)
# define fdc_log(fmt, ...) # define fdc_log(fmt, ...)
#endif #endif
const device_t fdc_internal_device = { const device_t fdc_internal_device = {
.name = "Internal", .name = "Internal",
.internal_name = "internal", .internal_name = "internal",
@@ -115,7 +108,6 @@ const device_t fdc_internal_device = {
.config = NULL .config = NULL
}; };
typedef const struct { typedef const struct {
const device_t *device; const device_t *device;
} fdc_cards_t; } fdc_cards_t;
@@ -131,7 +123,6 @@ static fdc_cards_t fdc_cards[] = {
// clang-format on // clang-format on
}; };
int int
fdc_card_available(int card) fdc_card_available(int card)
{ {
@@ -141,30 +132,27 @@ fdc_card_available(int card)
return (1); return (1);
} }
const device_t * const device_t *
fdc_card_getdevice(int card) fdc_card_getdevice(int card)
{ {
return (fdc_cards[card].device); return (fdc_cards[card].device);
} }
int int
fdc_card_has_config(int card) fdc_card_has_config(int card)
{ {
if (! fdc_cards[card].device) return(0); if (!fdc_cards[card].device)
return (0);
return (device_has_config(fdc_cards[card].device) ? 1 : 0); return (device_has_config(fdc_cards[card].device) ? 1 : 0);
} }
char * char *
fdc_card_get_internal_name(int card) fdc_card_get_internal_name(int card)
{ {
return device_get_internal_name(fdc_cards[card].device); return device_get_internal_name(fdc_cards[card].device);
} }
int int
fdc_card_get_from_internal_name(char *s) fdc_card_get_from_internal_name(char *s)
{ {
@@ -179,7 +167,6 @@ fdc_card_get_from_internal_name(char *s)
return (0); return (0);
} }
void void
fdc_card_init(void) fdc_card_init(void)
{ {
@@ -189,14 +176,12 @@ fdc_card_init(void)
device_add(fdc_cards[fdc_type].device); device_add(fdc_cards[fdc_type].device);
} }
uint8_t uint8_t
fdc_get_current_drive(void) fdc_get_current_drive(void)
{ {
return current_drive; return current_drive;
} }
void void
fdc_ctrl_reset(void *p) fdc_ctrl_reset(void *p)
{ {
@@ -212,14 +197,12 @@ fdc_ctrl_reset(void *p)
fdc->rate = 2; fdc->rate = 2;
} }
sector_id_t sector_id_t
fdc_get_read_track_sector(fdc_t *fdc) fdc_get_read_track_sector(fdc_t *fdc)
{ {
return fdc->read_track_sector; return fdc->read_track_sector;
} }
int int
fdc_get_compare_condition(fdc_t *fdc) fdc_get_compare_condition(fdc_t *fdc)
{ {
@@ -234,40 +217,34 @@ fdc_get_compare_condition(fdc_t *fdc)
} }
} }
int int
fdc_is_deleted(fdc_t *fdc) fdc_is_deleted(fdc_t *fdc)
{ {
return fdc->deleted & 1; return fdc->deleted & 1;
} }
int int
fdc_is_sk(fdc_t *fdc) fdc_is_sk(fdc_t *fdc)
{ {
return (fdc->deleted & 0x20) ? 1 : 0; return (fdc->deleted & 0x20) ? 1 : 0;
} }
void void
fdc_set_wrong_am(fdc_t *fdc) fdc_set_wrong_am(fdc_t *fdc)
{ {
fdc->wrong_am = 1; fdc->wrong_am = 1;
} }
int int
fdc_get_drive(fdc_t *fdc) fdc_get_drive(fdc_t *fdc)
{ {
return fdc->drive; return fdc->drive;
} }
int fdc_get_bitcell_period(fdc_t *fdc); int fdc_get_bitcell_period(fdc_t *fdc);
int fdc_get_bit_rate(fdc_t *fdc); int fdc_get_bit_rate(fdc_t *fdc);
static void fdc_rate(fdc_t *fdc, int drive); static void fdc_rate(fdc_t *fdc, int drive);
int int
fdc_get_perp(fdc_t *fdc) fdc_get_perp(fdc_t *fdc)
{ {
@@ -277,7 +254,6 @@ fdc_get_perp(fdc_t *fdc)
return fdc->perp; return fdc->perp;
} }
int int
fdc_get_gap2(fdc_t *fdc, int drive) fdc_get_gap2(fdc_t *fdc, int drive)
{ {
@@ -294,21 +270,18 @@ fdc_get_gap2(fdc_t *fdc, int drive)
} }
} }
int int
fdc_get_format_n(fdc_t *fdc) fdc_get_format_n(fdc_t *fdc)
{ {
return fdc->format_n; return fdc->format_n;
} }
int int
fdc_is_mfm(fdc_t *fdc) fdc_is_mfm(fdc_t *fdc)
{ {
return fdc->mfm ? 1 : 0; return fdc->mfm ? 1 : 0;
} }
void void
fdc_request_next_sector_id(fdc_t *fdc) fdc_request_next_sector_id(fdc_t *fdc)
{ {
@@ -320,35 +293,30 @@ fdc_request_next_sector_id(fdc_t *fdc)
} }
} }
void void
fdc_stop_id_request(fdc_t *fdc) fdc_stop_id_request(fdc_t *fdc)
{ {
fdc->stat &= 0x7f; fdc->stat &= 0x7f;
} }
int int
fdc_get_gap(fdc_t *fdc) fdc_get_gap(fdc_t *fdc)
{ {
return fdc->gap; return fdc->gap;
} }
int int
fdc_get_dtl(fdc_t *fdc) fdc_get_dtl(fdc_t *fdc)
{ {
return fdc->dtl; return fdc->dtl;
} }
int int
fdc_get_format_sectors(fdc_t *fdc) fdc_get_format_sectors(fdc_t *fdc)
{ {
return fdc->format_sectors; return fdc->format_sectors;
} }
static void static void
fdc_reset_fifo_buf(fdc_t *fdc) fdc_reset_fifo_buf(fdc_t *fdc)
{ {
@@ -356,7 +324,6 @@ fdc_reset_fifo_buf(fdc_t *fdc)
fdc->fifobufpos = 0; fdc->fifobufpos = 0;
} }
static void static void
fdc_fifo_buf_advance(fdc_t *fdc) fdc_fifo_buf_advance(fdc_t *fdc)
{ {
@@ -366,7 +333,6 @@ fdc_fifo_buf_advance(fdc_t *fdc)
fdc->fifobufpos++; fdc->fifobufpos++;
} }
static void static void
fdc_fifo_buf_write(fdc_t *fdc, uint8_t val) fdc_fifo_buf_write(fdc_t *fdc, uint8_t val)
{ {
@@ -374,7 +340,6 @@ fdc_fifo_buf_write(fdc_t *fdc, uint8_t val)
fdc_fifo_buf_advance(fdc); fdc_fifo_buf_advance(fdc);
} }
static int static int
fdc_fifo_buf_read(fdc_t *fdc) fdc_fifo_buf_read(fdc_t *fdc)
{ {
@@ -385,9 +350,8 @@ fdc_fifo_buf_read(fdc_t *fdc)
return temp; return temp;
} }
static void
static fdc_int(fdc_t *fdc, int set_fintr)
void fdc_int(fdc_t *fdc, int set_fintr)
{ {
int ienable = 0; int ienable = 0;
@@ -402,7 +366,6 @@ void fdc_int(fdc_t *fdc, int set_fintr)
fdc_log("fdc_int(%i): fdc->fintr = %i\n", set_fintr, fdc->fintr); fdc_log("fdc_int(%i): fdc->fintr = %i\n", set_fintr, fdc->fintr);
} }
static void static void
fdc_watchdog_poll(void *priv) fdc_watchdog_poll(void *priv)
{ {
@@ -417,7 +380,6 @@ fdc_watchdog_poll(void *priv)
} }
} }
/* fdc->rwc per Winbond W83877F datasheet: /* fdc->rwc per Winbond W83877F datasheet:
0 = normal; 0 = normal;
1 = 500 kbps, 360 rpm; 1 = 500 kbps, 360 rpm;
@@ -437,14 +399,12 @@ fdc_update_rates(fdc_t *fdc)
fdc_rate(fdc, 3); fdc_rate(fdc, 3);
} }
void void
fdc_update_max_track(fdc_t *fdc, int max_track) fdc_update_max_track(fdc_t *fdc, int max_track)
{ {
fdc->max_track = max_track; fdc->max_track = max_track;
} }
void void
fdc_update_enh_mode(fdc_t *fdc, int enh_mode) fdc_update_enh_mode(fdc_t *fdc, int enh_mode)
{ {
@@ -452,14 +412,12 @@ fdc_update_enh_mode(fdc_t *fdc, int enh_mode)
fdc_update_rates(fdc); fdc_update_rates(fdc);
} }
int int
fdc_get_rwc(fdc_t *fdc, int drive) fdc_get_rwc(fdc_t *fdc, int drive)
{ {
return fdc->rwc[drive]; return fdc->rwc[drive];
} }
void void
fdc_update_rwc(fdc_t *fdc, int drive, int rwc) fdc_update_rwc(fdc_t *fdc, int drive, int rwc)
{ {
@@ -468,21 +426,18 @@ fdc_update_rwc(fdc_t *fdc, int drive, int rwc)
fdc_rate(fdc, drive); fdc_rate(fdc, drive);
} }
int int
fdc_get_boot_drive(fdc_t *fdc) fdc_get_boot_drive(fdc_t *fdc)
{ {
return fdc->boot_drive; return fdc->boot_drive;
} }
void void
fdc_update_boot_drive(fdc_t *fdc, int boot_drive) fdc_update_boot_drive(fdc_t *fdc, int boot_drive)
{ {
fdc->boot_drive = boot_drive; fdc->boot_drive = boot_drive;
} }
void void
fdc_update_densel_polarity(fdc_t *fdc, int densel_polarity) fdc_update_densel_polarity(fdc_t *fdc, int densel_polarity)
{ {
@@ -491,14 +446,12 @@ fdc_update_densel_polarity(fdc_t *fdc, int densel_polarity)
fdc_update_rates(fdc); fdc_update_rates(fdc);
} }
uint8_t uint8_t
fdc_get_densel_polarity(fdc_t *fdc) fdc_get_densel_polarity(fdc_t *fdc)
{ {
return fdc->densel_polarity; return fdc->densel_polarity;
} }
void void
fdc_update_densel_force(fdc_t *fdc, int densel_force) fdc_update_densel_force(fdc_t *fdc, int densel_force)
{ {
@@ -507,7 +460,6 @@ fdc_update_densel_force(fdc_t *fdc, int densel_force)
fdc_update_rates(fdc); fdc_update_rates(fdc);
} }
void void
fdc_update_drvrate(fdc_t *fdc, int drive, int drvrate) fdc_update_drvrate(fdc_t *fdc, int drive, int drvrate)
{ {
@@ -516,14 +468,12 @@ fdc_update_drvrate(fdc_t *fdc, int drive, int drvrate)
fdc_rate(fdc, drive); fdc_rate(fdc, drive);
} }
void void
fdc_update_drv2en(fdc_t *fdc, int drv2en) fdc_update_drv2en(fdc_t *fdc, int drv2en)
{ {
fdc->drv2en = drv2en; fdc->drv2en = drv2en;
} }
void void
fdc_update_rate(fdc_t *fdc, int drive) fdc_update_rate(fdc_t *fdc, int drive)
{ {
@@ -531,7 +481,8 @@ fdc_update_rate(fdc_t *fdc, int drive)
fdc->bit_rate = 500; fdc->bit_rate = 500;
else if ((fdc->rwc[drive] == 3) && fdc->enh_mode) else if ((fdc->rwc[drive] == 3) && fdc->enh_mode)
fdc->bit_rate = 250; fdc->bit_rate = 250;
else switch (fdc->rate) { else
switch (fdc->rate) {
case 0: /*High density*/ case 0: /*High density*/
fdc->bit_rate = 500; fdc->bit_rate = 500;
break; break;
@@ -559,7 +510,6 @@ fdc_update_rate(fdc_t *fdc, int drive)
fdc->bitcell_period = (1000000 / fdc->bit_rate) * 2; /*Bitcell period in ns*/ fdc->bitcell_period = (1000000 / fdc->bit_rate) * 2; /*Bitcell period in ns*/
} }
int int
fdc_get_bit_rate(fdc_t *fdc) fdc_get_bit_rate(fdc_t *fdc)
{ {
@@ -580,14 +530,12 @@ fdc_get_bit_rate(fdc_t *fdc)
return 2; return 2;
} }
int int
fdc_get_bitcell_period(fdc_t *fdc) fdc_get_bitcell_period(fdc_t *fdc)
{ {
return fdc->bitcell_period; return fdc->bitcell_period;
} }
static int static int
fdc_get_densel(fdc_t *fdc, int drive) fdc_get_densel(fdc_t *fdc, int drive)
{ {
@@ -629,7 +577,6 @@ fdc_get_densel(fdc_t *fdc, int drive)
return 0; return 0;
} }
static void static void
fdc_rate(fdc_t *fdc, int drive) fdc_rate(fdc_t *fdc, int drive)
{ {
@@ -640,7 +587,6 @@ fdc_rate(fdc_t *fdc, int drive)
fdc_log("FDD %c: [%i] Densel: %i\n", 0x41 + drive, fdc->enh_mode, fdc_get_densel(fdc, drive)); fdc_log("FDD %c: [%i] Densel: %i\n", 0x41 + drive, fdc->enh_mode, fdc_get_densel(fdc, drive));
} }
int int
real_drive(fdc_t *fdc, int drive) real_drive(fdc_t *fdc, int drive)
{ {
@@ -650,7 +596,6 @@ real_drive(fdc_t *fdc, int drive)
return drive; return drive;
} }
void void
fdc_seek(fdc_t *fdc, int drive, int params) fdc_seek(fdc_t *fdc, int drive, int params)
{ {
@@ -658,7 +603,6 @@ fdc_seek(fdc_t *fdc, int drive, int params)
fdc->stat |= (1 << fdc->drive); fdc->stat |= (1 << fdc->drive);
} }
static void static void
fdc_bad_command(fdc_t *fdc) fdc_bad_command(fdc_t *fdc)
{ {
@@ -667,7 +611,6 @@ fdc_bad_command(fdc_t *fdc)
timer_set_delay_u64(&fdc->timer, 100 * TIMER_USEC); timer_set_delay_u64(&fdc->timer, 100 * TIMER_USEC);
} }
static void static void
fdc_io_command_phase1(fdc_t *fdc, int out) fdc_io_command_phase1(fdc_t *fdc, int out)
{ {
@@ -711,7 +654,6 @@ fdc_io_command_phase1(fdc_t *fdc, int out)
fdc->inread = 1; fdc->inread = 1;
} }
static void static void
fdc_sis(fdc_t *fdc) fdc_sis(fdc_t *fdc)
{ {
@@ -746,7 +688,6 @@ fdc_sis(fdc_t *fdc)
fdc->paramstogo = 2; fdc->paramstogo = 2;
} }
static void static void
fdc_write(uint16_t addr, uint8_t val, void *priv) fdc_write(uint16_t addr, uint8_t val, void *priv)
{ {
@@ -860,11 +801,7 @@ fdc_write(uint16_t addr, uint8_t val, void *priv)
fdc_log("Starting FDC command %02X\n", fdc->command); fdc_log("Starting FDC command %02X\n", fdc->command);
fdc->error = 0; fdc->error = 0;
if (((fdc->command & 0x1f) == 0x02) || ((fdc->command & 0x1f) == 0x05) || if (((fdc->command & 0x1f) == 0x02) || ((fdc->command & 0x1f) == 0x05) || ((fdc->command & 0x1f) == 0x06) || ((fdc->command & 0x1f) == 0x0a) || ((fdc->command & 0x1f) == 0x0c) || ((fdc->command & 0x1f) == 0x0d) || ((fdc->command & 0x1f) == 0x11) || ((fdc->command & 0x1f) == 0x16) || ((fdc->command & 0x1f) == 0x19) || ((fdc->command & 0x1f) == 0x1d))
((fdc->command & 0x1f) == 0x06) || ((fdc->command & 0x1f) == 0x0a) ||
((fdc->command & 0x1f) == 0x0c) || ((fdc->command & 0x1f) == 0x0d) ||
((fdc->command & 0x1f) == 0x11) || ((fdc->command & 0x1f) == 0x16) ||
((fdc->command & 0x1f) == 0x19) || ((fdc->command & 0x1f) == 0x1d))
fdc->processed_cmd = fdc->command & 0x1f; fdc->processed_cmd = fdc->command & 0x1f;
else else
fdc->processed_cmd = fdc->command; fdc->processed_cmd = fdc->command;
@@ -922,7 +859,8 @@ fdc_write(uint16_t addr, uint8_t val, void *priv)
fdc->sc = 0; fdc->sc = 0;
fdc->wrong_am = 0; fdc->wrong_am = 0;
fdc->deleted = ((fdc->command & 0x1F) == 0xC) ? 1 : 0; fdc->deleted = ((fdc->command & 0x1F) == 0xC) ? 1 : 0;
if ((fdc->command&0x1F) == 0x16) fdc->deleted = 2; if ((fdc->command & 0x1F) == 0x16)
fdc->deleted = 2;
fdc->deleted |= (fdc->command & 0x20); fdc->deleted |= (fdc->command & 0x20);
fdc->pnum = 0; fdc->pnum = 0;
fdc->ptot = 8; fdc->ptot = 8;
@@ -1160,8 +1098,7 @@ fdc_write(uint16_t addr, uint8_t val, void *priv)
fdc->stat = 0x70; fdc->stat = 0x70;
else else
fdc->stat = 0x50; fdc->stat = 0x50;
} } else
else
fdc_noidam(fdc); fdc_noidam(fdc);
break; break;
case 0x0d: /* Format */ case 0x0d: /* Format */
@@ -1282,7 +1219,6 @@ fdc_write(uint16_t addr, uint8_t val, void *priv)
} }
} }
uint8_t uint8_t
fdc_read(uint16_t addr, void *priv) fdc_read(uint16_t addr, void *priv)
{ {
@@ -1343,12 +1279,10 @@ fdc_read(uint16_t addr, void *priv)
if (is486 || !fdc->enable_3f1) if (is486 || !fdc->enable_3f1)
ret = 0xff; ret = 0xff;
else { else {
if(fdc->flags & FDC_FLAG_UMC) if (fdc->flags & FDC_FLAG_UMC) {
{
drive = real_drive(fdc, fdc->dor & 1); drive = real_drive(fdc, fdc->dor & 1);
ret = !fdd_is_dd(drive) ? ((fdc->dor & 1) ? 2 : 1) : 0; ret = !fdd_is_dd(drive) ? ((fdc->dor & 1) ? 2 : 1) : 0;
} } else {
else {
ret = 0x70; ret = 0x70;
drive = real_drive(fdc, fdc->dor & 3); drive = real_drive(fdc, fdc->dor & 3);
@@ -1520,7 +1454,6 @@ fdc_poll_common_finish(fdc_t *fdc, int compare, int st5)
dma_set_drq(fdc->dma_ch, 0); dma_set_drq(fdc->dma_ch, 0);
} }
static void static void
fdc_poll_readwrite_finish(fdc_t *fdc, int compare) fdc_poll_readwrite_finish(fdc_t *fdc, int compare)
{ {
@@ -1533,7 +1466,6 @@ fdc_poll_readwrite_finish(fdc_t *fdc, int compare)
fdc_poll_common_finish(fdc, compare, 0); fdc_poll_common_finish(fdc, compare, 0);
} }
static void static void
fdc_no_dma_end(fdc_t *fdc, int compare) fdc_no_dma_end(fdc_t *fdc, int compare)
{ {
@@ -1542,7 +1474,6 @@ fdc_no_dma_end(fdc_t *fdc, int compare)
fdc_poll_common_finish(fdc, compare, 0x80); fdc_poll_common_finish(fdc, compare, 0x80);
} }
static void static void
fdc_callback(void *priv) fdc_callback(void *priv)
{ {
@@ -1833,7 +1764,6 @@ fdc_callback(void *priv)
} }
} }
void void
fdc_error(fdc_t *fdc, int st5, int st6) fdc_error(fdc_t *fdc, int st5, int st6)
{ {
@@ -1919,7 +1849,6 @@ fdc_error(fdc_t *fdc, int st5, int st6)
#endif #endif
} }
void void
fdc_overrun(fdc_t *fdc) fdc_overrun(fdc_t *fdc)
{ {
@@ -1928,14 +1857,12 @@ fdc_overrun(fdc_t *fdc)
fdc_error(fdc, 0x10, 0); fdc_error(fdc, 0x10, 0);
} }
int int
fdc_is_verify(fdc_t *fdc) fdc_is_verify(fdc_t *fdc)
{ {
return (fdc->deleted & 2) ? 1 : 0; return (fdc->deleted & 2) ? 1 : 0;
} }
int int
fdc_data(fdc_t *fdc, uint8_t data, int last) fdc_data(fdc_t *fdc, uint8_t data, int last)
{ {
@@ -2018,14 +1945,12 @@ fdc_data(fdc_t *fdc, uint8_t data, int last)
return 0; return 0;
} }
void void
fdc_finishread(fdc_t *fdc) fdc_finishread(fdc_t *fdc)
{ {
fdc->inread = 0; fdc->inread = 0;
} }
void void
fdc_track_finishread(fdc_t *fdc, int condition) fdc_track_finishread(fdc_t *fdc, int condition)
{ {
@@ -2035,7 +1960,6 @@ fdc_track_finishread(fdc_t *fdc, int condition)
fdc_callback(fdc); fdc_callback(fdc);
} }
void void
fdc_sector_finishcompare(fdc_t *fdc, int satisfying) fdc_sector_finishcompare(fdc_t *fdc, int satisfying)
{ {
@@ -2046,7 +1970,6 @@ fdc_sector_finishcompare(fdc_t *fdc, int satisfying)
fdc_callback(fdc); fdc_callback(fdc);
} }
void void
fdc_sector_finishread(fdc_t *fdc) fdc_sector_finishread(fdc_t *fdc)
{ {
@@ -2055,7 +1978,6 @@ fdc_sector_finishread(fdc_t *fdc)
fdc_callback(fdc); fdc_callback(fdc);
} }
/* There is no sector ID. */ /* There is no sector ID. */
void void
fdc_noidam(fdc_t *fdc) fdc_noidam(fdc_t *fdc)
@@ -2063,65 +1985,60 @@ fdc_noidam(fdc_t *fdc)
fdc_error(fdc, 1, 0); fdc_error(fdc, 1, 0);
} }
/* Sector ID's are there, but there is no sector. */ /* Sector ID's are there, but there is no sector. */
void fdc_nosector(fdc_t *fdc) void
fdc_nosector(fdc_t *fdc)
{ {
fdc_error(fdc, 4, 0); fdc_error(fdc, 4, 0);
} }
/* There is no sector data. */ /* There is no sector data. */
void fdc_nodataam(fdc_t *fdc) void
fdc_nodataam(fdc_t *fdc)
{ {
fdc_error(fdc, 1, 1); fdc_error(fdc, 1, 1);
} }
/* Abnormal termination with both status 1 and 2 set to 0, used when abnormally /* Abnormal termination with both status 1 and 2 set to 0, used when abnormally
terminating the fdc_t FORMAT TRACK command. */ terminating the fdc_t FORMAT TRACK command. */
void fdc_cannotformat(fdc_t *fdc) void
fdc_cannotformat(fdc_t *fdc)
{ {
fdc_error(fdc, 0, 0); fdc_error(fdc, 0, 0);
} }
void void
fdc_datacrcerror(fdc_t *fdc) fdc_datacrcerror(fdc_t *fdc)
{ {
fdc_error(fdc, 0x20, 0x20); fdc_error(fdc, 0x20, 0x20);
} }
void void
fdc_headercrcerror(fdc_t *fdc) fdc_headercrcerror(fdc_t *fdc)
{ {
fdc_error(fdc, 0x20, 0); fdc_error(fdc, 0x20, 0);
} }
void void
fdc_wrongcylinder(fdc_t *fdc) fdc_wrongcylinder(fdc_t *fdc)
{ {
fdc_error(fdc, 4, 0x10); fdc_error(fdc, 4, 0x10);
} }
void void
fdc_badcylinder(fdc_t *fdc) fdc_badcylinder(fdc_t *fdc)
{ {
fdc_error(fdc, 4, 0x02); fdc_error(fdc, 4, 0x02);
} }
void void
fdc_writeprotect(fdc_t *fdc) fdc_writeprotect(fdc_t *fdc)
{ {
fdc_error(fdc, 0x02, 0); fdc_error(fdc, 0x02, 0);
} }
int
int fdc_getdata(fdc_t *fdc, int last) fdc_getdata(fdc_t *fdc, int last)
{ {
int i, data = 0; int i, data = 0;
@@ -2176,7 +2093,6 @@ int fdc_getdata(fdc_t *fdc, int last)
return data & 0xff; return data & 0xff;
} }
void void
fdc_sectorid(fdc_t *fdc, uint8_t track, uint8_t side, uint8_t sector, uint8_t size, uint8_t crc1, uint8_t crc2) fdc_sectorid(fdc_t *fdc, uint8_t track, uint8_t side, uint8_t sector, uint8_t size, uint8_t crc1, uint8_t crc2)
{ {
@@ -2194,21 +2110,18 @@ fdc_sectorid(fdc_t *fdc, uint8_t track, uint8_t side, uint8_t sector, uint8_t si
dma_set_drq(fdc->dma_ch, 0); dma_set_drq(fdc->dma_ch, 0);
} }
uint8_t uint8_t
fdc_get_swwp(fdc_t *fdc) fdc_get_swwp(fdc_t *fdc)
{ {
return fdc->swwp; return fdc->swwp;
} }
void void
fdc_set_swwp(fdc_t *fdc, uint8_t swwp) fdc_set_swwp(fdc_t *fdc, uint8_t swwp)
{ {
fdc->swwp = swwp; fdc->swwp = swwp;
} }
uint8_t uint8_t
fdc_get_diswr(fdc_t *fdc) fdc_get_diswr(fdc_t *fdc)
{ {
@@ -2218,42 +2131,36 @@ fdc_get_diswr(fdc_t *fdc)
return fdc->disable_write; return fdc->disable_write;
} }
void void
fdc_set_diswr(fdc_t *fdc, uint8_t diswr) fdc_set_diswr(fdc_t *fdc, uint8_t diswr)
{ {
fdc->disable_write = diswr; fdc->disable_write = diswr;
} }
uint8_t uint8_t
fdc_get_swap(fdc_t *fdc) fdc_get_swap(fdc_t *fdc)
{ {
return fdc->swap; return fdc->swap;
} }
void void
fdc_set_swap(fdc_t *fdc, uint8_t swap) fdc_set_swap(fdc_t *fdc, uint8_t swap)
{ {
fdc->swap = swap; fdc->swap = swap;
} }
void void
fdc_set_irq(fdc_t *fdc, int irq) fdc_set_irq(fdc_t *fdc, int irq)
{ {
fdc->irq = irq; fdc->irq = irq;
} }
void void
fdc_set_dma_ch(fdc_t *fdc, int dma_ch) fdc_set_dma_ch(fdc_t *fdc, int dma_ch)
{ {
fdc->dma_ch = dma_ch; fdc->dma_ch = dma_ch;
} }
void void
fdc_set_base(fdc_t *fdc, int base) fdc_set_base(fdc_t *fdc, int base)
{ {
@@ -2285,7 +2192,6 @@ fdc_set_base(fdc_t *fdc, int base)
fdc_log("FDC Base address set%s (%04X)\n", super_io ? " for Super I/O" : "", fdc->base_address); fdc_log("FDC Base address set%s (%04X)\n", super_io ? " for Super I/O" : "", fdc->base_address);
} }
void void
fdc_remove(fdc_t *fdc) fdc_remove(fdc_t *fdc)
{ {
@@ -2316,7 +2222,6 @@ fdc_remove(fdc_t *fdc)
} }
} }
void void
fdc_reset(void *priv) fdc_reset(void *priv)
{ {
@@ -2378,7 +2283,6 @@ fdc_reset(void *priv)
ui_sb_update_icon(SB_FLOPPY | i, 0); ui_sb_update_icon(SB_FLOPPY | i, 0);
} }
static void static void
fdc_close(void *priv) fdc_close(void *priv)
{ {
@@ -2392,7 +2296,6 @@ fdc_close(void *priv)
free(fdc); free(fdc);
} }
static void * static void *
fdc_init(const device_t *info) fdc_init(const device_t *info)
{ {
@@ -2424,7 +2327,6 @@ fdc_init(const device_t *info)
return fdc; return fdc;
} }
void void
fdc_3f1_enable(fdc_t *fdc, int enable) fdc_3f1_enable(fdc_t *fdc, int enable)
{ {

13
src/floppy/fdc_magitronic.c
View File

@@ -59,19 +59,15 @@ b215_read(uint16_t addr, void *priv)
*/ */
int drive_spec[2]; int drive_spec[2];
for (int i = 0; i <= 1; i++) for (int i = 0; i <= 1; i++) {
{ if (fdd_is_525(DRIVE_SELECT)) {
if (fdd_is_525(DRIVE_SELECT))
{
if (!fdd_is_dd(DRIVE_SELECT)) if (!fdd_is_dd(DRIVE_SELECT))
drive_spec[i] = 1; drive_spec[i] = 1;
else if (fdd_doublestep_40(DRIVE_SELECT)) else if (fdd_doublestep_40(DRIVE_SELECT))
drive_spec[i] = 2; drive_spec[i] = 2;
else else
drive_spec[i] = 0; drive_spec[i] = 0;
} } else {
else
{
if (fdd_is_dd(DRIVE_SELECT) && !fdd_is_double_sided(DRIVE_SELECT)) if (fdd_is_dd(DRIVE_SELECT) && !fdd_is_double_sided(DRIVE_SELECT))
drive_spec[i] = 0; drive_spec[i] = 0;
else if (fdd_is_dd(DRIVE_SELECT) && fdd_is_double_sided(DRIVE_SELECT)) else if (fdd_is_dd(DRIVE_SELECT) && fdd_is_double_sided(DRIVE_SELECT))
@@ -106,7 +102,8 @@ b215_init(const device_t *info)
return dev; return dev;
} }
static int b215_available(void) static int
b215_available(void)
{ {
return rom_present(ROM_B215); return rom_present(ROM_B215);
} }

6
src/floppy/fdc_pii15xb.c
View File

@@ -111,12 +111,14 @@ pii_init(const device_t *info)
return dev; return dev;
} }
static int pii_151b_available(void) static int
pii_151b_available(void)
{ {
return rom_present(ROM_PII_151B); return rom_present(ROM_PII_151B);
} }
static int pii_158_available(void) static int
pii_158_available(void)
{ {
return rom_present(ROM_PII_158B); return rom_present(ROM_PII_158B);
} }

65
src/floppy/fdd.c
View File

@@ -39,7 +39,6 @@
#include <86box/fdd_td0.h> #include <86box/fdd_td0.h>
#include <86box/fdc.h> #include <86box/fdc.h>
/* Flags: /* Flags:
Bit 0: 300 rpm supported; Bit 0: 300 rpm supported;
Bit 1: 360 rpm supported; Bit 1: 360 rpm supported;
@@ -65,7 +64,6 @@
#define FLAG_IGNORE_DENSEL 512 #define FLAG_IGNORE_DENSEL 512
#define FLAG_PS2 1024 #define FLAG_PS2 1024
typedef struct { typedef struct {
int type; int type;
int track; int track;
@@ -75,7 +73,6 @@ typedef struct {
int check_bpb; int check_bpb;
} fdd_t; } fdd_t;
fdd_t fdd[FDD_NUM]; fdd_t fdd[FDD_NUM];
char floppyfns[FDD_NUM][512]; char floppyfns[FDD_NUM][512];
@@ -97,15 +94,13 @@ fdc_t *fdd_fdc;
d86f_handler_t d86f_handler[FDD_NUM]; d86f_handler_t d86f_handler[FDD_NUM];
static const struct static const struct
{ {
char *ext; char *ext;
void (*load)(int drive, char *fn); void (*load)(int drive, char *fn);
void (*close)(int drive); void (*close)(int drive);
int size; int size;
} loaders[]= } loaders[] = {
{
{"001", img_load, img_close, -1}, {"001", img_load, img_close, -1},
{ "002", img_load, img_close, -1}, { "002", img_load, img_close, -1},
{ "003", img_load, img_close, -1}, { "003", img_load, img_close, -1},
@@ -141,7 +136,6 @@ static const struct
{ 0, 0, 0, 0 } { 0, 0, 0, 0 }
}; };
static const struct static const struct
{ {
int max_track; int max_track;
@@ -197,18 +191,15 @@ static const struct
} }
}; };
#ifdef ENABLE_FDD_LOG #ifdef ENABLE_FDD_LOG
int fdd_do_log = ENABLE_FDD_LOG; int fdd_do_log = ENABLE_FDD_LOG;
static void static void
fdd_log(const char *fmt, ...) fdd_log(const char *fmt, ...)
{ {
va_list ap; va_list ap;
if (fdd_do_log) if (fdd_do_log) {
{
va_start(ap, fmt); va_start(ap, fmt);
pclog_ex(fmt, ap); pclog_ex(fmt, ap);
va_end(ap); va_end(ap);
@@ -218,21 +209,18 @@ fdd_log(const char *fmt, ...)
# define fdd_log(fmt, ...) # define fdd_log(fmt, ...)
#endif #endif
char * char *
fdd_getname(int type) fdd_getname(int type)
{ {
return (char *) drive_types[type].name; return (char *) drive_types[type].name;
} }
char * char *
fdd_get_internal_name(int type) fdd_get_internal_name(int type)
{ {
return (char *) drive_types[type].internal_name; return (char *) drive_types[type].internal_name;
} }
int int
fdd_get_from_internal_name(char *s) fdd_get_from_internal_name(char *s)
{ {
@@ -247,7 +235,6 @@ fdd_get_from_internal_name(char *s)
return 0; return 0;
} }
/* This is needed for the dump as 86F feature. */ /* This is needed for the dump as 86F feature. */
void void
fdd_do_seek(int drive, int track) fdd_do_seek(int drive, int track)
@@ -256,7 +243,6 @@ fdd_do_seek(int drive, int track)
drives[drive].seek(drive, track); drives[drive].seek(drive, track);
} }
void void
fdd_forced_seek(int drive, int track_diff) fdd_forced_seek(int drive, int track_diff)
{ {
@@ -271,7 +257,6 @@ fdd_forced_seek(int drive, int track_diff)
fdd_do_seek(drive, fdd[drive].track); fdd_do_seek(drive, fdd[drive].track);
} }
void void
fdd_seek(int drive, int track_diff) fdd_seek(int drive, int track_diff)
{ {
@@ -291,24 +276,22 @@ fdd_seek(int drive, int track_diff)
fdd_do_seek(drive, fdd[drive].track); fdd_do_seek(drive, fdd[drive].track);
} }
int int
fdd_track0(int drive) fdd_track0(int drive)
{ {
/* If drive is disabled, TRK0 never gets set. */ /* If drive is disabled, TRK0 never gets set. */
if (!drive_types[fdd[drive].type].max_track) return 0; if (!drive_types[fdd[drive].type].max_track)
return 0;
return !fdd[drive].track; return !fdd[drive].track;
} }
int int
fdd_current_track(int drive) fdd_current_track(int drive)
{ {
return fdd[drive].track; return fdd[drive].track;
} }
void void
fdd_set_densel(int densel) fdd_set_densel(int densel)
{ {
@@ -322,7 +305,6 @@ fdd_set_densel(int densel)
} }
} }
int int
fdd_getrpm(int drive) fdd_getrpm(int drive)
{ {
@@ -351,7 +333,6 @@ fdd_getrpm(int drive)
} }
} }
int int
fdd_can_read_medium(int drive) fdd_can_read_medium(int drive)
{ {
@@ -362,14 +343,12 @@ fdd_can_read_medium(int drive)
return !!(drive_types[fdd[drive].type].flags & hole); return !!(drive_types[fdd[drive].type].flags & hole);
} }
int int
fdd_doublestep_40(int drive) fdd_doublestep_40(int drive)
{ {
return !!(drive_types[fdd[drive].type].flags & FLAG_DOUBLE_STEP); return !!(drive_types[fdd[drive].type].flags & FLAG_DOUBLE_STEP);
} }
void void
fdd_set_type(int drive, int type) fdd_set_type(int drive, int type)
{ {
@@ -379,49 +358,42 @@ fdd_set_type(int drive, int type)
fdd[drive].densel ^= 1; fdd[drive].densel ^= 1;
} }
int int
fdd_get_type(int drive) fdd_get_type(int drive)
{ {
return fdd[drive].type; return fdd[drive].type;
} }
int int
fdd_get_flags(int drive) fdd_get_flags(int drive)
{ {
return drive_types[fdd[drive].type].flags; return drive_types[fdd[drive].type].flags;
} }
int int
fdd_is_525(int drive) fdd_is_525(int drive)
{ {
return drive_types[fdd[drive].type].flags & FLAG_525; return drive_types[fdd[drive].type].flags & FLAG_525;
} }
int int
fdd_is_dd(int drive) fdd_is_dd(int drive)
{ {
return (drive_types[fdd[drive].type].flags & 0x70) == 0x10; return (drive_types[fdd[drive].type].flags & 0x70) == 0x10;
} }
int int
fdd_is_ed(int drive) fdd_is_ed(int drive)
{ {
return drive_types[fdd[drive].type].flags & FLAG_HOLE2; return drive_types[fdd[drive].type].flags & FLAG_HOLE2;
} }
int int
fdd_is_double_sided(int drive) fdd_is_double_sided(int drive)
{ {
return drive_types[fdd[drive].type].flags & FLAG_DS; return drive_types[fdd[drive].type].flags & FLAG_DS;
} }
void void
fdd_set_head(int drive, int head) fdd_set_head(int drive, int head)
{ {
@@ -431,7 +403,6 @@ fdd_set_head(int drive, int head)
fdd[drive].head = head; fdd[drive].head = head;
} }
int int
fdd_get_head(int drive) fdd_get_head(int drive)
{ {
@@ -440,41 +411,36 @@ fdd_get_head(int drive)
return fdd[drive].head; return fdd[drive].head;
} }
void void
fdd_set_turbo(int drive, int turbo) fdd_set_turbo(int drive, int turbo)
{ {
fdd[drive].turbo = turbo; fdd[drive].turbo = turbo;
} }
int int
fdd_get_turbo(int drive) fdd_get_turbo(int drive)
{ {
return fdd[drive].turbo; return fdd[drive].turbo;
} }
void
void fdd_set_check_bpb(int drive, int check_bpb) fdd_set_check_bpb(int drive, int check_bpb)
{ {
fdd[drive].check_bpb = check_bpb; fdd[drive].check_bpb = check_bpb;
} }
int int
fdd_get_check_bpb(int drive) fdd_get_check_bpb(int drive)
{ {
return fdd[drive].check_bpb; return fdd[drive].check_bpb;
} }
int int
fdd_get_densel(int drive) fdd_get_densel(int drive)
{ {
return fdd[drive].densel; return fdd[drive].densel;
} }
void void
fdd_load(int drive, char *fn) fdd_load(int drive, char *fn)
{ {
@@ -498,7 +464,8 @@ fdd_load(int drive, char *fn)
while (loaders[c].ext) { while (loaders[c].ext) {
if (!strcasecmp(p, (char *) loaders[c].ext) && (size == loaders[c].size || loaders[c].size == -1)) { if (!strcasecmp(p, (char *) loaders[c].ext) && (size == loaders[c].size || loaders[c].size == -1)) {
driveloaders[drive] = c; driveloaders[drive] = c;
if (floppyfns[drive] != fn) strcpy(floppyfns[drive], fn); if (floppyfns[drive] != fn)
strcpy(floppyfns[drive], fn);
d86f_setup(drive); d86f_setup(drive);
loaders[c].load(drive, floppyfns[drive]); loaders[c].load(drive, floppyfns[drive]);
drive_empty[drive] = 0; drive_empty[drive] = 0;
@@ -516,7 +483,6 @@ fdd_load(int drive, char *fn)
ui_sb_update_icon_state(SB_FLOPPY | drive, 1); ui_sb_update_icon_state(SB_FLOPPY | drive, 1);
} }
void void
fdd_close(int drive) fdd_close(int drive)
{ {
@@ -542,7 +508,6 @@ fdd_close(int drive)
ui_sb_update_icon_state(SB_FLOPPY | drive, 1); ui_sb_update_icon_state(SB_FLOPPY | drive, 1);
} }
int int
fdd_hole(int drive) fdd_hole(int drive)
{ {
@@ -552,7 +517,6 @@ fdd_hole(int drive)
return 0; return 0;
} }
static __inline uint64_t static __inline uint64_t
fdd_byteperiod(int drive) fdd_byteperiod(int drive)
{ {
@@ -562,7 +526,6 @@ fdd_byteperiod(int drive)
return 32ULL * TIMER_USEC; return 32ULL * TIMER_USEC;
} }
void void
fdd_set_motor_enable(int drive, int motor_enable) fdd_set_motor_enable(int drive, int motor_enable)
{ {
@@ -574,7 +537,6 @@ fdd_set_motor_enable(int drive, int motor_enable)
motoron[drive] = motor_enable; motoron[drive] = motor_enable;
} }
static void static void
fdd_poll(void *priv) fdd_poll(void *priv)
{ {
@@ -598,7 +560,6 @@ fdd_poll(void *priv)
} }
} }
int int
fdd_get_bitcell_period(int rate) fdd_get_bitcell_period(int rate)
{ {
@@ -622,7 +583,6 @@ fdd_get_bitcell_period(int rate)
return 1000000 / bit_rate * 2; /*Bitcell period in ns*/ return 1000000 / bit_rate * 2; /*Bitcell period in ns*/
} }
void void
fdd_reset(void) fdd_reset(void)
{ {
@@ -634,7 +594,6 @@ fdd_reset(void)
} }
} }
void void
fdd_readsector(int drive, int sector, int track, int side, int density, int sector_size) fdd_readsector(int drive, int sector, int track, int side, int density, int sector_size)
{ {
@@ -644,7 +603,6 @@ fdd_readsector(int drive, int sector, int track, int side, int density, int sect
fdd_notfound = 1000; fdd_notfound = 1000;
} }
void void
fdd_writesector(int drive, int sector, int track, int side, int density, int sector_size) fdd_writesector(int drive, int sector, int track, int side, int density, int sector_size)
{ {
@@ -654,7 +612,6 @@ fdd_writesector(int drive, int sector, int track, int side, int density, int sec
fdd_notfound = 1000; fdd_notfound = 1000;
} }
void void
fdd_comparesector(int drive, int sector, int track, int side, int density, int sector_size) fdd_comparesector(int drive, int sector, int track, int side, int density, int sector_size)
{ {
@@ -664,7 +621,6 @@ fdd_comparesector(int drive, int sector, int track, int side, int density, int s
fdd_notfound = 1000; fdd_notfound = 1000;
} }
void void
fdd_readaddress(int drive, int side, int density) fdd_readaddress(int drive, int side, int density)
{ {
@@ -672,7 +628,6 @@ fdd_readaddress(int drive, int side, int density)
drives[drive].readaddress(drive, side, density); drives[drive].readaddress(drive, side, density);
} }
void void
fdd_format(int drive, int side, int density, uint8_t fill) fdd_format(int drive, int side, int density, uint8_t fill)
{ {
@@ -682,7 +637,6 @@ fdd_format(int drive, int side, int density, uint8_t fill)
fdd_notfound = 1000; fdd_notfound = 1000;
} }
void void
fdd_stop(int drive) fdd_stop(int drive)
{ {
@@ -690,14 +644,12 @@ fdd_stop(int drive)
drives[drive].stop(drive); drives[drive].stop(drive);
} }
void void
fdd_set_fdc(void *fdc) fdd_set_fdc(void *fdc)
{ {
fdd_fdc = (fdc_t *) fdc; fdd_fdc = (fdc_t *) fdc;
} }
void void
fdd_init(void) fdd_init(void)
{ {
@@ -720,7 +672,6 @@ fdd_init(void)
} }
} }
void void
fdd_do_writeback(int drive) fdd_do_writeback(int drive)
{ {

251
src/floppy/fdd_86f.c
View File

File diff suppressed because it is too large Load Diff

7
src/floppy/fdd_common.c
View File

@@ -24,7 +24,6 @@
#include <86box/fdd.h> #include <86box/fdd.h>
#include <86box/fdd_common.h> #include <86box/fdd_common.h>
const uint8_t fdd_holes[6] = { 0, 0, 0, 1, 1, 2 }; const uint8_t fdd_holes[6] = { 0, 0, 0, 1, 1, 2 };
const uint8_t fdd_rates[6] = { 2, 2, 1, 4, 0, 3 }; const uint8_t fdd_rates[6] = { 2, 2, 1, 4, 0, 3 };
@@ -63,7 +62,6 @@ const uint8_t fdd_dmf_r[21] = {
12, 2, 13, 3, 14, 4, 15, 5, 16, 6, 17, 7, 18, 8, 19, 9, 20, 10, 21, 11, 1 12, 2, 13, 3, 14, 4, 15, 5, 16, 6, 17, 7, 18, 8, 19, 9, 20, 10, 21, 11, 1
}; };
static const uint8_t fdd_gap3_sizes[5][8][48] = { static const uint8_t fdd_gap3_sizes[5][8][48] = {
{ { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* [0][0] */ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* [0][0] */
@@ -347,14 +345,12 @@ static const uint8_t fdd_gap3_sizes[5][8][48] = {
} }
}; };
int int
fdd_get_gap3_size(int rate, int size, int sector) fdd_get_gap3_size(int rate, int size, int sector)
{ {
return (fdd_gap3_sizes[rate][size][sector]); return (fdd_gap3_sizes[rate][size][sector]);
} }
uint8_t uint8_t
fdd_sector_size_code(int size) fdd_sector_size_code(int size)
{ {
@@ -400,14 +396,12 @@ fdd_sector_size_code(int size)
return (ret); return (ret);
} }
int int
fdd_sector_code_size(uint8_t code) fdd_sector_code_size(uint8_t code)
{ {
return (128 << code); return (128 << code);
} }
int int
fdd_bps_valid(uint16_t bps) fdd_bps_valid(uint16_t bps)
{ {
@@ -422,7 +416,6 @@ fdd_bps_valid(uint16_t bps)
return (0); return (0);
} }
int int
fdd_interleave(int sector, int skew, int spt) fdd_interleave(int sector, int skew, int spt)
{ {

28
src/floppy/fdd_fdi.c
View File

@@ -36,7 +36,6 @@
#include <86box/fdc.h> #include <86box/fdc.h>
#include <fdi2raw.h> #include <fdi2raw.h>
typedef struct { typedef struct {
FILE *f; FILE *f;
FDI *h; FDI *h;
@@ -51,22 +50,18 @@ typedef struct {
uint8_t track_timing[2][4][256 * 1024]; uint8_t track_timing[2][4][256 * 1024];
} fdi_t; } fdi_t;
static fdi_t *fdi[FDD_NUM]; static fdi_t *fdi[FDD_NUM];
static fdc_t *fdi_fdc; static fdc_t *fdi_fdc;
#ifdef ENABLE_FDI_LOG #ifdef ENABLE_FDI_LOG
int fdi_do_log = ENABLE_FDI_LOG; int fdi_do_log = ENABLE_FDI_LOG;
static void static void
fdi_log(const char *fmt, ...) fdi_log(const char *fmt, ...)
{ {
va_list ap; va_list ap;
if (fdi_do_log) if (fdi_do_log) {
{
va_start(ap, fmt); va_start(ap, fmt);
pclog_ex(fmt, ap); pclog_ex(fmt, ap);
va_end(ap); va_end(ap);
@@ -76,7 +71,6 @@ fdi_log(const char *fmt, ...)
# define fdi_log(fmt, ...) # define fdi_log(fmt, ...)
#endif #endif
static uint16_t static uint16_t
disk_flags(int drive) disk_flags(int drive)
{ {
@@ -113,7 +107,6 @@ disk_flags(int drive)
return (temp_disk_flags); return (temp_disk_flags);
} }
static uint16_t static uint16_t
side_flags(int drive) side_flags(int drive)
{ {
@@ -153,11 +146,11 @@ side_flags(int drive)
return (temp_side_flags); return (temp_side_flags);
} }
static int static int
fdi_density(void) fdi_density(void)
{ {
if (! fdc_is_mfm(fdi_fdc)) return(0); if (!fdc_is_mfm(fdi_fdc))
return (0);
switch (fdc_get_bit_rate(fdi_fdc)) { switch (fdc_get_bit_rate(fdi_fdc)) {
case 0: case 0:
@@ -180,7 +173,6 @@ fdi_density(void)
return (1); return (1);
} }
static int32_t static int32_t
extra_bit_cells(int drive, int side) extra_bit_cells(int drive, int side)
{ {
@@ -218,7 +210,6 @@ extra_bit_cells(int drive, int side)
return ((dev->tracklen[side][density] - raw_size)); return ((dev->tracklen[side][density] - raw_size));
} }
static void static void
read_revolution(int drive) read_revolution(int drive)
{ {
@@ -254,7 +245,6 @@ read_revolution(int drive)
} }
} }
static uint32_t static uint32_t
index_hole_pos(int drive, int side) index_hole_pos(int drive, int side)
{ {
@@ -266,7 +256,6 @@ index_hole_pos(int drive, int side)
return (dev->trackindex[side][density]); return (dev->trackindex[side][density]);
} }
static uint32_t static uint32_t
get_raw_size(int drive, int side) get_raw_size(int drive, int side)
{ {
@@ -278,7 +267,6 @@ get_raw_size(int drive, int side)
return (dev->tracklen[side][density]); return (dev->tracklen[side][density]);
} }
static uint16_t * static uint16_t *
encoded_data(int drive, int side) encoded_data(int drive, int side)
{ {
@@ -290,7 +278,6 @@ encoded_data(int drive, int side)
return ((uint16_t *) dev->track_data[side][density]); return ((uint16_t *) dev->track_data[side][density]);
} }
void void
fdi_seek(int drive, int track) fdi_seek(int drive, int track)
{ {
@@ -303,7 +290,8 @@ fdi_seek(int drive, int track)
d86f_set_cur_track(drive, track); d86f_set_cur_track(drive, track);
if (dev->f == NULL) return; if (dev->f == NULL)
return;
if (track < 0) if (track < 0)
track = 0; track = 0;
@@ -318,7 +306,6 @@ fdi_seek(int drive, int track)
read_revolution(drive); read_revolution(drive);
} }
void void
fdi_load(int drive, char *fn) fdi_load(int drive, char *fn)
{ {
@@ -383,13 +370,13 @@ fdi_load(int drive, char *fn)
fdi_log("Loaded as FDI\n"); fdi_log("Loaded as FDI\n");
} }
void void
fdi_close(int drive) fdi_close(int drive)
{ {
fdi_t *dev = fdi[drive]; fdi_t *dev = fdi[drive];
if (dev == NULL) return; if (dev == NULL)
return;
d86f_unregister(drive); d86f_unregister(drive);
@@ -406,7 +393,6 @@ fdi_close(int drive)
fdi[drive] = NULL; fdi[drive] = NULL;
} }
void void
fdi_set_fdc(void *fdc) fdi_set_fdc(void *fdc)
{ {

69
src/floppy/fdd_imd.c
View File

@@ -31,7 +31,6 @@
#include <86box/fdd_imd.h> #include <86box/fdd_imd.h>
#include <86box/fdc.h> #include <86box/fdc.h>
typedef struct { typedef struct {
uint8_t is_present; uint8_t is_present;
uint32_t file_offs; uint32_t file_offs;
@@ -64,22 +63,18 @@ typedef struct {
uint8_t track_buffer[2][25000]; uint8_t track_buffer[2][25000];
} imd_t; } imd_t;
static imd_t *imd[FDD_NUM]; static imd_t *imd[FDD_NUM];
static fdc_t *imd_fdc; static fdc_t *imd_fdc;
#ifdef ENABLE_IMD_LOG #ifdef ENABLE_IMD_LOG
int imd_do_log = ENABLE_IMD_LOG; int imd_do_log = ENABLE_IMD_LOG;
static void static void
imd_log(const char *fmt, ...) imd_log(const char *fmt, ...)
{ {
va_list ap; va_list ap;
if (imd_do_log) if (imd_do_log) {
{
va_start(ap, fmt); va_start(ap, fmt);
pclog_ex(fmt, ap); pclog_ex(fmt, ap);
va_end(ap); va_end(ap);
@@ -89,7 +84,6 @@ imd_log(const char *fmt, ...)
# define imd_log(fmt, ...) # define imd_log(fmt, ...)
#endif #endif
static uint32_t static uint32_t
get_raw_tsize(int side_flags, int slower_rpm) get_raw_tsize(int side_flags, int slower_rpm)
{ {
@@ -138,7 +132,6 @@ get_raw_tsize(int side_flags, int slower_rpm)
return (size); return (size);
} }
static int static int
track_is_xdf(int drive, int side, int track) track_is_xdf(int drive, int side, int track)
{ {
@@ -154,15 +147,17 @@ track_is_xdf(int drive, int side, int track)
for (i = 0; i < 256; i++) for (i = 0; i < 256; i++)
dev->xdf_ordered_pos[i][side] = 0; dev->xdf_ordered_pos[i][side] = 0;
if (dev->tracks[track][side].params[2] & 0xC0) return(0); if (dev->tracks[track][side].params[2] & 0xC0)
return (0);
if ((dev->tracks[track][side].params[3] != 16) && if ((dev->tracks[track][side].params[3] != 16) && (dev->tracks[track][side].params[3] != 19))
(dev->tracks[track][side].params[3] != 19)) return(0); return (0);
r_map = (uint8_t *) (dev->buffer + dev->tracks[track][side].r_map_offs); r_map = (uint8_t *) (dev->buffer + dev->tracks[track][side].r_map_offs);
if (!track) { if (!track) {
if (dev->tracks[track][side].params[4] != 2) return(0); if (dev->tracks[track][side].params[4] != 2)
return (0);
if (!side) { if (!side) {
max_high_id = (dev->tracks[track][side].params[3] == 19) ? 0x8B : 0x88; max_high_id = (dev->tracks[track][side].params[3] == 19) ? 0x8B : 0x88;
@@ -190,7 +185,8 @@ track_is_xdf(int drive, int side, int track)
} }
return (0); return (0);
} else { } else {
if (dev->tracks[track][side].params[4] != 0xFF) return(0); if (dev->tracks[track][side].params[4] != 0xFF)
return (0);
n_map = (uint8_t *) (dev->buffer + dev->tracks[track][side].n_map_offs); n_map = (uint8_t *) (dev->buffer + dev->tracks[track][side].n_map_offs);
@@ -221,7 +217,6 @@ track_is_xdf(int drive, int side, int track)
return (0); return (0);
} }
static int static int
track_is_interleave(int drive, int side, int track) track_is_interleave(int drive, int side, int track)
{ {
@@ -239,11 +234,14 @@ track_is_interleave(int drive, int side, int track)
r_map = dev->buffer + dev->tracks[track][side].r_map_offs; r_map = dev->buffer + dev->tracks[track][side].r_map_offs;
if (dev->tracks[track][side].params[2] & 0xC0) return(0); if (dev->tracks[track][side].params[2] & 0xC0)
return (0);
if (track_spt != 21) return(0); if (track_spt != 21)
return (0);
if (dev->tracks[track][side].params[4] != 2) return(0); if (dev->tracks[track][side].params[4] != 2)
return (0);
for (i = 0; i < track_spt; i++) { for (i = 0; i < track_spt; i++) {
if ((r_map[i] >= 1) && (r_map[i] <= track_spt)) { if ((r_map[i] >= 1) && (r_map[i] <= track_spt)) {
@@ -252,12 +250,12 @@ track_is_interleave(int drive, int side, int track)
} }
} }
if (effective_sectors == track_spt) return(1); if (effective_sectors == track_spt)
return (1);
return (0); return (0);
} }
static void static void
sector_to_buffer(int drive, int track, int side, uint8_t *buffer, int sector, int len) sector_to_buffer(int drive, int track, int side, uint8_t *buffer, int sector, int len)
{ {
@@ -277,7 +275,6 @@ sector_to_buffer(int drive, int track, int side, uint8_t *buffer, int sector, in
} }
} }
static void static void
imd_seek(int drive, int track) imd_seek(int drive, int track)
{ {
@@ -306,7 +303,8 @@ imd_seek(int drive, int track)
uint8_t *data; uint8_t *data;
int flags = 0x00; int flags = 0x00;
if (dev->f == NULL) return; if (dev->f == NULL)
return;
if (!dev->track_width && fdd_doublestep_40(drive)) if (!dev->track_width && fdd_doublestep_40(drive))
track /= 2; track /= 2;
@@ -444,7 +442,6 @@ imd_seek(int drive, int track)
} }
} }
static uint16_t static uint16_t
disk_flags(int drive) disk_flags(int drive)
{ {
@@ -453,7 +450,6 @@ disk_flags(int drive)
return (dev->disk_flags); return (dev->disk_flags);
} }
static uint16_t static uint16_t
side_flags(int drive) side_flags(int drive)
{ {
@@ -467,7 +463,6 @@ side_flags(int drive)
return (sflags); return (sflags);
} }
static void static void
set_sector(int drive, int side, uint8_t c, uint8_t h, uint8_t r, uint8_t n) set_sector(int drive, int side, uint8_t c, uint8_t h, uint8_t r, uint8_t n)
{ {
@@ -489,7 +484,8 @@ set_sector(int drive, int side, uint8_t c, uint8_t h, uint8_t r, uint8_t n)
if (sn == 0xFF) if (sn == 0xFF)
n_map = dev->buffer + dev->tracks[track][side].n_map_offs; n_map = dev->buffer + dev->tracks[track][side].n_map_offs;
if (c != dev->track) return; if (c != dev->track)
return;
for (i = 0; i < dev->tracks[track][side].params[3]; i++) { for (i = 0; i < dev->tracks[track][side].params[3]; i++) {
id[0] = (sh & 0x80) ? c_map[i] : sc; id[0] = (sh & 0x80) ? c_map[i] : sc;
@@ -502,7 +498,6 @@ set_sector(int drive, int side, uint8_t c, uint8_t h, uint8_t r, uint8_t n)
} }
} }
static void static void
imd_writeback(int drive) imd_writeback(int drive)
{ {
@@ -514,7 +509,8 @@ imd_writeback(int drive)
uint8_t h, n, spt; uint8_t h, n, spt;
uint32_t ssize; uint32_t ssize;
if (writeprot[drive]) return; if (writeprot[drive])
return;
for (side = 0; side < dev->sides; side++) { for (side = 0; side < dev->sides; side++) {
if (dev->tracks[track][side].is_present) { if (dev->tracks[track][side].is_present) {
@@ -543,14 +539,14 @@ imd_writeback(int drive)
} }
} }
static uint8_t static uint8_t
poll_read_data(int drive, int side, uint16_t pos) poll_read_data(int drive, int side, uint16_t pos)
{ {
imd_t *dev = imd[drive]; imd_t *dev = imd[drive];
int type = dev->current_data[side][0]; int type = dev->current_data[side][0];
if ((type == 0) || (type > 8)) return(0xf6); /* Should never happen. */ if ((type == 0) || (type > 8))
return (0xf6); /* Should never happen. */
if (type & 1) if (type & 1)
return (dev->current_data[side][pos + 1]); return (dev->current_data[side][pos + 1]);
@@ -558,21 +554,21 @@ poll_read_data(int drive, int side, uint16_t pos)
return (dev->current_data[side][1]); return (dev->current_data[side][1]);
} }
static void static void
poll_write_data(int drive, int side, uint16_t pos, uint8_t data) poll_write_data(int drive, int side, uint16_t pos, uint8_t data)
{ {
imd_t *dev = imd[drive]; imd_t *dev = imd[drive];
int type = dev->current_data[side][0]; int type = dev->current_data[side][0];
if (writeprot[drive]) return; if (writeprot[drive])
return;
if ((type & 1) || (type == 0) || (type > 8)) return; /* Should never happen. */ if ((type & 1) || (type == 0) || (type > 8))
return; /* Should never happen. */
dev->current_data[side][pos + 1] = data; dev->current_data[side][pos + 1] = data;
} }
static int static int
format_conditions(int drive) format_conditions(int drive)
{ {
@@ -587,14 +583,12 @@ format_conditions(int drive)
return (temp); return (temp);
} }
void void
imd_init(void) imd_init(void)
{ {
memset(imd, 0x00, sizeof(imd)); memset(imd, 0x00, sizeof(imd));
} }
void void
imd_load(int drive, char *fn) imd_load(int drive, char *fn)
{ {
@@ -911,13 +905,13 @@ imd_load(int drive, char *fn)
d86f_common_handlers(drive); d86f_common_handlers(drive);
} }
void void
imd_close(int drive) imd_close(int drive)
{ {
imd_t *dev = imd[drive]; imd_t *dev = imd[drive];
if (dev == NULL) return; if (dev == NULL)
return;
d86f_unregister(drive); d86f_unregister(drive);
@@ -932,7 +926,6 @@ imd_close(int drive)
imd[drive] = NULL; imd[drive] = NULL;
} }
void void
imd_set_fdc(void *fdc) imd_set_fdc(void *fdc)
{ {

60
src/floppy/fdd_json.c
View File

@@ -60,12 +60,10 @@
#include <86box/fdd_common.h> #include <86box/fdd_common.h>
#include <86box/fdd_json.h> #include <86box/fdd_json.h>
#define NTRACKS 256 #define NTRACKS 256
#define NSIDES 2 #define NSIDES 2
#define NSECTORS 256 #define NSECTORS 256
typedef struct { typedef struct {
uint8_t track, /* ID: track number */ uint8_t track, /* ID: track number */
side, /* side number */ side, /* side number */
@@ -104,22 +102,18 @@ typedef struct {
sector_t sects[NTRACKS][NSIDES][NSECTORS]; sector_t sects[NTRACKS][NSIDES][NSECTORS];
} json_t; } json_t;
static json_t *images[FDD_NUM]; static json_t *images[FDD_NUM];
#define ENABLE_JSON_LOG 1 #define ENABLE_JSON_LOG 1
#ifdef ENABLE_JSON_LOG #ifdef ENABLE_JSON_LOG
int json_do_log = ENABLE_JSON_LOG; int json_do_log = ENABLE_JSON_LOG;
static void static void
json_log(const char *fmt, ...) json_log(const char *fmt, ...)
{ {
va_list ap; va_list ap;
if (json_do_log) if (json_do_log) {
{
va_start(ap, fmt); va_start(ap, fmt);
pclog_ex(fmt, ap); pclog_ex(fmt, ap);
va_end(ap); va_end(ap);
@@ -129,7 +123,6 @@ json_log(const char *fmt, ...)
# define json_log(fmt, ...) # define json_log(fmt, ...)
#endif #endif
static void static void
handle(json_t *dev, char *name, char *str) handle(json_t *dev, char *name, char *str)
{ {
@@ -188,7 +181,8 @@ handle(json_t *dev, char *name, char *str)
p = sec->data; p = sec->data;
while (str && *str) { while (str && *str) {
sp = strchr(str, ','); sp = strchr(str, ',');
if (sp != NULL) *sp++ = '\0'; if (sp != NULL)
*sp++ = '\0';
l = atol(str); l = atol(str);
*p++ = (l & 0x000000ff); *p++ = (l & 0x000000ff);
@@ -204,7 +198,6 @@ handle(json_t *dev, char *name, char *str)
} }
} }
static int static int
unexpect(int c, int state, int level) unexpect(int c, int state, int level)
{ {
@@ -213,7 +206,6 @@ unexpect(int c, int state, int level)
return (-1); return (-1);
} }
static int static int
load_image(json_t *dev) load_image(json_t *dev)
{ {
@@ -330,7 +322,8 @@ load_image(json_t *dev)
case ']': /* all sectors done */ case ']': /* all sectors done */
if (--level == 0) if (--level == 0)
state = -1; state = -1;
else state++; else
state++;
break; break;
default: default:
@@ -347,7 +340,8 @@ load_image(json_t *dev)
case ']': /* all sides done */ case ']': /* all sides done */
if (--level == 0) if (--level == 0)
state = -1; state = -1;
else state++; else
state++;
break; break;
default: default:
@@ -367,7 +361,8 @@ load_image(json_t *dev)
case ']': /* all tracks done */ case ']': /* all tracks done */
if (--level == 0) if (--level == 0)
state = -1; state = -1;
else state++; else
state++;
break; break;
default: default:
@@ -376,7 +371,6 @@ load_image(json_t *dev)
dev->track++; dev->track++;
break; break;
} }
} }
/* Save derived values. */ /* Save derived values. */
@@ -386,7 +380,6 @@ load_image(json_t *dev)
return (1); return (1);
} }
/* Seek the heads to a track, and prepare to read data from that track. */ /* Seek the heads to a track, and prepare to read data from that track. */
static void static void
json_seek(int drive, int track) json_seek(int drive, int track)
@@ -403,7 +396,8 @@ json_seek(int drive, int track)
} }
/* Allow for doublestepping tracks. */ /* Allow for doublestepping tracks. */
if (! dev->track_width && fdd_doublestep_40(drive)) track /= 2; if (!dev->track_width && fdd_doublestep_40(drive))
track /= 2;
/* Set the new track. */ /* Set the new track. */
dev->track = track; dev->track = track;
@@ -423,7 +417,8 @@ json_seek(int drive, int track)
for (side = 0; side < dev->sides; side++) { for (side = 0; side < dev->sides; side++) {
/* Get transfer rate for this side. */ /* Get transfer rate for this side. */
rate = dev->track_flags & 0x07; rate = dev->track_flags & 0x07;
if (!rate && (dev->track_flags & 0x20)) rate = 4; if (!rate && (dev->track_flags & 0x20))
rate = 4;
/* Get correct GAP3 value for this side. */ /* Get correct GAP3 value for this side. */
gap3 = fdd_get_gap3_size(rate, gap3 = fdd_get_gap3_size(rate,
@@ -460,7 +455,6 @@ json_seek(int drive, int track)
} }
} }
static uint16_t static uint16_t
disk_flags(int drive) disk_flags(int drive)
{ {
@@ -469,7 +463,6 @@ disk_flags(int drive)
return (dev->disk_flags); return (dev->disk_flags);
} }
static uint16_t static uint16_t
track_flags(int drive) track_flags(int drive)
{ {
@@ -478,7 +471,6 @@ track_flags(int drive)
return (dev->track_flags); return (dev->track_flags);
} }
static void static void
set_sector(int drive, int side, uint8_t c, uint8_t h, uint8_t r, uint8_t n) set_sector(int drive, int side, uint8_t c, uint8_t h, uint8_t r, uint8_t n)
{ {
@@ -488,23 +480,20 @@ set_sector(int drive, int side, uint8_t c, uint8_t h, uint8_t r, uint8_t n)
dev->sector[side] = 0; dev->sector[side] = 0;
/* Make sure we are on the desired track. */ /* Make sure we are on the desired track. */
if (c != dev->track) return; if (c != dev->track)
return;
/* Set the desired side. */ /* Set the desired side. */
dev->side = side; dev->side = side;
/* Now loop over all sector ID's on this side to find our sector. */ /* Now loop over all sector ID's on this side to find our sector. */
for (i = 0; i < dev->spt[c][side]; i++) { for (i = 0; i < dev->spt[c][side]; i++) {
if ((dev->sects[dev->track][side][i].track == c) && 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->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; dev->sector[side] = i;
} }
} }
} }
static uint8_t static uint8_t
poll_read_data(int drive, int side, uint16_t pos) poll_read_data(int drive, int side, uint16_t pos)
{ {
@@ -514,14 +503,12 @@ poll_read_data(int drive, int side, uint16_t pos)
return (dev->sects[dev->track][side][sec].data[pos]); return (dev->sects[dev->track][side][sec].data[pos]);
} }
void void
json_init(void) json_init(void)
{ {
memset(images, 0x00, sizeof(images)); memset(images, 0x00, sizeof(images));
} }
void void
json_load(int drive, char *fn) json_load(int drive, char *fn)
{ {
@@ -587,24 +574,21 @@ json_load(int drive, char *fn)
temp_rate = 0xff; temp_rate = 0xff;
sec = &dev->sects[0][0][0]; sec = &dev->sects[0][0][0];
for (i = 0; i < 6; i++) { for (i = 0; i < 6; i++) {
if (dev->spt[0][0] > fdd_max_sectors[sec->size][i]) continue; if (dev->spt[0][0] > fdd_max_sectors[sec->size][i])
continue;
bit_rate = fdd_bit_rates_300[i]; bit_rate = fdd_bit_rates_300[i];
temp_rate = fdd_rates[i]; temp_rate = fdd_rates[i];
dev->disk_flags |= (fdd_holes[i] << 1); dev->disk_flags |= (fdd_holes[i] << 1);
if ((bit_rate == 500.0) && (dev->spt[0][0] == 21) && if ((bit_rate == 500.0) && (dev->spt[0][0] == 21) && (sec->size == 2) && (dev->tracks >= 80) && (dev->tracks <= 82) && (dev->sides == 2)) {
(sec->size == 2) && (dev->tracks >= 80) &&
(dev->tracks <= 82) && (dev->sides == 2)) {
/* /*
* This is a DMF floppy, set the flag so * This is a DMF floppy, set the flag so
* we know to interleave the sectors. * we know to interleave the sectors.
*/ */
dev->dmf = 1; dev->dmf = 1;
} else { } else {
if ((bit_rate == 500.0) && (dev->spt[0][0] == 22) && if ((bit_rate == 500.0) && (dev->spt[0][0] == 22) && (sec->size == 2) && (dev->tracks >= 80) && (dev->tracks <= 82) && (dev->sides == 2)) {
(sec->size == 2) && (dev->tracks >= 80) &&
(dev->tracks <= 82) && (dev->sides == 2)) {
/* /*
* This is marked specially because of the * This is marked specially because of the
* track flag (a RPM slow down is needed). * track flag (a RPM slow down is needed).
@@ -680,7 +664,6 @@ json_load(int drive, char *fn)
drives[drive].seek = json_seek; drives[drive].seek = json_seek;
} }
/* Close the image. */ /* Close the image. */
void void
json_close(int drive) json_close(int drive)
@@ -688,7 +671,8 @@ json_close(int drive)
json_t *dev = images[drive]; json_t *dev = images[drive];
int t, h, s; int t, h, s;
if (dev == NULL) return; if (dev == NULL)
return;
/* Unlink image from the system. */ /* Unlink image from the system. */
d86f_unregister(drive); d86f_unregister(drive);

31
src/floppy/fdd_mfm.c
View File

@@ -31,7 +31,6 @@
#include <86box/fdd_mfm.h> #include <86box/fdd_mfm.h>
#include <86box/fdc.h> #include <86box/fdc.h>
#pragma pack(push, 1) #pragma pack(push, 1)
typedef struct { typedef struct {
uint8_t hdr_name[7]; uint8_t hdr_name[7];
@@ -79,22 +78,18 @@ typedef struct {
uint8_t track_data[2][256 * 1024]; uint8_t track_data[2][256 * 1024];
} mfm_t; } mfm_t;
static mfm_t *mfm[FDD_NUM]; static mfm_t *mfm[FDD_NUM];
static fdc_t *mfm_fdc; static fdc_t *mfm_fdc;
#ifdef ENABLE_MFM_LOG #ifdef ENABLE_MFM_LOG
int mfm_do_log = ENABLE_MFM_LOG; int mfm_do_log = ENABLE_MFM_LOG;
static void static void
mfm_log(const char *fmt, ...) mfm_log(const char *fmt, ...)
{ {
va_list ap; va_list ap;
if (mfm_do_log) if (mfm_do_log) {
{
va_start(ap, fmt); va_start(ap, fmt);
pclog_ex(fmt, ap); pclog_ex(fmt, ap);
va_end(ap); va_end(ap);
@@ -104,7 +99,6 @@ mfm_log(const char *fmt, ...)
# define mfm_log(fmt, ...) # define mfm_log(fmt, ...)
#endif #endif
static int static int
get_track_index(int drive, int side, int track) get_track_index(int drive, int side, int track)
{ {
@@ -112,8 +106,7 @@ get_track_index(int drive, int side, int track)
int i, ret = -1; int i, ret = -1;
for (i = 0; i < dev->total_tracks; i++) { for (i = 0; i < dev->total_tracks; i++) {
if ((dev->tracks[i].track_no == track) && if ((dev->tracks[i].track_no == track) && (dev->tracks[i].side_no == side)) {
(dev->tracks[i].side_no == side)) {
ret = i; ret = i;
break; break;
} }
@@ -122,7 +115,6 @@ get_track_index(int drive, int side, int track)
return ret; return ret;
} }
static int static int
get_adv_track_index(int drive, int side, int track) get_adv_track_index(int drive, int side, int track)
{ {
@@ -130,8 +122,7 @@ get_adv_track_index(int drive, int side, int track)
int i, ret = -1; int i, ret = -1;
for (i = 0; i < dev->total_tracks; i++) { for (i = 0; i < dev->total_tracks; i++) {
if ((dev->adv_tracks[i].track_no == track) && if ((dev->adv_tracks[i].track_no == track) && (dev->adv_tracks[i].side_no == side)) {
(dev->adv_tracks[i].side_no == side)) {
ret = i; ret = i;
break; break;
} }
@@ -140,7 +131,6 @@ get_adv_track_index(int drive, int side, int track)
return ret; return ret;
} }
static void static void
get_adv_track_bitrate(int drive, int side, int track, int *br, int *rpm) get_adv_track_bitrate(int drive, int side, int track, int *br, int *rpm)
{ {
@@ -161,7 +151,6 @@ get_adv_track_bitrate(int drive, int side, int track, int *br, int *rpm)
} }
} }
static void static void
set_disk_flags(int drive) set_disk_flags(int drive)
{ {
@@ -201,7 +190,6 @@ set_disk_flags(int drive)
dev->disk_flags = temp_disk_flags; dev->disk_flags = temp_disk_flags;
} }
static uint16_t static uint16_t
disk_flags(int drive) disk_flags(int drive)
{ {
@@ -210,7 +198,6 @@ disk_flags(int drive)
return dev->disk_flags; return dev->disk_flags;
} }
static void static void
set_side_flags(int drive, int side) set_side_flags(int drive, int side)
{ {
@@ -262,7 +249,6 @@ set_side_flags(int drive, int side)
dev->side_flags[side] = temp_side_flags; dev->side_flags[side] = temp_side_flags;
} }
static uint16_t static uint16_t
side_flags(int drive) side_flags(int drive)
{ {
@@ -274,7 +260,6 @@ side_flags(int drive)
return dev->side_flags[side]; return dev->side_flags[side];
} }
static uint32_t static uint32_t
get_raw_size(int drive, int side) get_raw_size(int drive, int side)
{ {
@@ -316,14 +301,12 @@ get_raw_size(int drive, int side)
return dev->tracks[track_index].track_size * 8; return dev->tracks[track_index].track_size * 8;
} }
static int32_t static int32_t
extra_bit_cells(int drive, int side) extra_bit_cells(int drive, int side)
{ {
return (int32_t) get_raw_size(drive, side); return (int32_t) get_raw_size(drive, side);
} }
static uint16_t * static uint16_t *
encoded_data(int drive, int side) encoded_data(int drive, int side)
{ {
@@ -332,7 +315,6 @@ encoded_data(int drive, int side)
return ((uint16_t *) dev->track_data[side]); return ((uint16_t *) dev->track_data[side]);
} }
void void
mfm_read_side(int drive, int side) mfm_read_side(int drive, int side)
{ {
@@ -367,7 +349,6 @@ mfm_read_side(int drive, int side)
drive, side, dev->cur_track, track_index, track_size); drive, side, dev->cur_track, track_index, track_size);
} }
void void
mfm_seek(int drive, int track) mfm_seek(int drive, int track)
{ {
@@ -396,7 +377,6 @@ mfm_seek(int drive, int track)
set_side_flags(drive, 1); set_side_flags(drive, 1);
} }
void void
mfm_load(int drive, char *fn) mfm_load(int drive, char *fn)
{ {
@@ -497,13 +477,13 @@ mfm_load(int drive, char *fn)
mfm_log("Loaded as MFM\n"); mfm_log("Loaded as MFM\n");
} }
void void
mfm_close(int drive) mfm_close(int drive)
{ {
mfm_t *dev = mfm[drive]; mfm_t *dev = mfm[drive];
if (dev == NULL) return; if (dev == NULL)
return;
d86f_unregister(drive); d86f_unregister(drive);
@@ -523,7 +503,6 @@ mfm_close(int drive)
mfm[drive] = NULL; mfm[drive] = NULL;
} }
void void
mfm_set_fdc(void *fdc) mfm_set_fdc(void *fdc)
{ {

410
src/floppy/fdi2raw.c
View File

File diff suppressed because it is too large Load Diff