pandory500/redquark-amiberry-rb
2
0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Indentation corrections in disk.cpp

Browse source
This commit is contained in:
Dimitris Panokostas 2020-05-03 17:49:48 +02:00
parent d870c6cea4
commit 6c26fcf631
1 changed files with 144 additions and 136 deletions
Download patch file Download diff file Expand all files Collapse all files

280
src/disk.cpp
View file

@ -642,45 +642,43 @@ static bool drive_writeprotected(drive* drv)
static void reset_drive(int num) static void reset_drive(int num)
{ {
drive *drv = &floppy[num]; drive* drv = &floppy[num];
drive_image_free (drv); drive_image_free(drv);
drv->motoroff = 1; drv->motoroff = 1;
drv->idbit = 0; drv->idbit = 0;
drv->drive_id = 0; drv->drive_id = 0;
drv->drive_id_scnt = 0; drv->drive_id_scnt = 0;
drv->lastdataacesstrack = -1; drv->lastdataacesstrack = -1;
disabled &= ~(1 << num); disabled &= ~(1 << num);
if (currprefs.floppyslots[num].dfxtype < 0 || ispcbridgedrive(num)) if (currprefs.floppyslots[num].dfxtype < 0 || ispcbridgedrive(num))
disabled |= 1 << num; disabled |= 1 << num;
reset_drive_gui(num); reset_drive_gui(num);
/* most internal Amiga floppy drives won't enable /* most internal Amiga floppy drives won't enable
* diskready until motor is running at full speed * diskready until motor is running at full speed
* and next indexsync has been passed * and next indexsync has been passed
*/ */
drv->indexhackmode = 0; drv->indexhackmode = 0;
if (num == 0 && currprefs.floppyslots[num].dfxtype == 0) if (num == 0 && currprefs.floppyslots[num].dfxtype == 0)
drv->indexhackmode = 1; drv->indexhackmode = 1;
drv->dskchange_time = 0; drv->dskchange_time = 0;
drv->dskchange = false; drv->dskchange = false;
drv->dskready_down_time = 0; drv->dskready_down_time = 0;
drv->dskready_up_time = 0; drv->dskready_up_time = 0;
drv->buffered_cyl = -1; drv->buffered_cyl = -1;
drv->buffered_side = -1; drv->buffered_side = -1;
gui_led (num + LED_DF0, 0, -1); gui_led(num + LED_DF0, 0, -1);
drive_settype_id (drv); drive_settype_id(drv);
_tcscpy (currprefs.floppyslots[num].df, changed_prefs.floppyslots[num].df); _tcscpy(currprefs.floppyslots[num].df, changed_prefs.floppyslots[num].df);
drv->newname[0] = 0; drv->newname[0] = 0;
drv->newnamewriteprotected = false; drv->newnamewriteprotected = false;
if (!drive_insert (drv, &currprefs, num, currprefs.floppyslots[num].df, false, false)) if (!drive_insert(drv, &currprefs, num, currprefs.floppyslots[num].df, false, false))
disk_eject (num); disk_eject(num);
} }
/* code for track display */ /* code for track display */
static void update_drive_gui(int num, bool force) static void update_drive_gui(int num, bool force)
{ {
if (num >= currprefs.nr_floppies)
return;
drive* drv = floppy + num; drive* drv = floppy + num;
bool writ = dskdmaen == DSKDMA_WRITE && drv->state && !((selected | disabled) & (1 << num)); bool writ = dskdmaen == DSKDMA_WRITE && drv->state && !((selected | disabled) & (1 << num));
struct gui_info_drive* gid = &gui_data.drives[num]; struct gui_info_drive* gid = &gui_data.drives[num];
@ -998,6 +996,10 @@ static bool diskfile_iswriteprotect (struct uae_prefs *p, const TCHAR *fname_in,
*needwritefile = 1; *needwritefile = 1;
return wrprot2; return wrprot2;
} }
if (strncmp ((uae_char*) buffer, "SCP", 3) == 0) {
*needwritefile = 1;
return wrprot2;
}
if (strncmp((uae_char *)buffer, "Formatted Disk Image file", 25) == 0) { if (strncmp((uae_char *)buffer, "Formatted Disk Image file", 25) == 0) {
*needwritefile = 1; *needwritefile = 1;
return wrprot2; return wrprot2;
@ -2297,6 +2299,8 @@ static void drive_write_data (drive * drv)
return; return;
case ADF_IPF: case ADF_IPF:
break; break;
case ADF_SCP:
break;
case ADF_PCDOS: case ADF_PCDOS:
ret = drive_write_pcdos (drv, drv->diskfile, 0); ret = drive_write_pcdos (drv, drv->diskfile, 0);
if (ret < 0) if (ret < 0)
@ -2558,14 +2562,14 @@ int disk_setwriteprotect (struct uae_prefs *p, int num, const TCHAR *fname_in, b
return 1; return 1;
} }
void disk_eject (int num) void disk_eject(int num)
{ {
set_config_changed (); set_config_changed();
gui_filename (num, _T("")); gui_filename(num, _T(""));
drive_eject (floppy + num); drive_eject(floppy + num);
*currprefs.floppyslots[num].df = *changed_prefs.floppyslots[num].df = 0; *currprefs.floppyslots[num].df = *changed_prefs.floppyslots[num].df = 0;
floppy[num].newname[0] = 0; floppy[num].newname[0] = 0;
update_drive_gui (num, true); update_drive_gui(num, true);
} }
static void disk_insert_2 (int num, const TCHAR *name, bool forced, bool forcedwriteprotect) static void disk_insert_2 (int num, const TCHAR *name, bool forced, bool forcedwriteprotect)
@ -2663,63 +2667,64 @@ void DISK_select_set (uae_u8 data)
fetch_DISK_select (data); fetch_DISK_select (data);
} }
void DISK_select (uae_u8 data) void DISK_select(uae_u8 data)
{ {
int step_pulse, prev_selected, dr; int step_pulse, prev_selected, dr;
prev_selected = selected; prev_selected = selected;
fetch_DISK_select (data); fetch_DISK_select(data);
step_pulse = data & 1; step_pulse = data & 1;
if ((prev_data & 0x80) != (data & 0x80)) { if ((prev_data & 0x80) != (data & 0x80)) {
for (dr = 0; dr < 4; dr++) { for (dr = 0; dr < 4; dr++) {
if (floppy[dr].indexhackmode > 1 && !((selected | disabled) & (1 << dr))) { if (floppy[dr].indexhackmode > 1 && !((selected | disabled) & (1 << dr))) {
floppy[dr].indexhack = 1; floppy[dr].indexhack = 1;
} }
} }
} }
// step goes high and drive was selected when step pulse changes: step // step goes high and drive was selected when step pulse changes: step
if (prev_step != step_pulse) { if (prev_step != step_pulse) {
prev_step = step_pulse; prev_step = step_pulse;
if (prev_step && !savestate_state) { if (prev_step && !savestate_state) {
for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) { for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) {
if (!((prev_selected | disabled) & (1 << dr))) { if (!((prev_selected | disabled) & (1 << dr))) {
drive_step (floppy + dr, direction); drive_step(floppy + dr, direction);
if (floppy[dr].indexhackmode > 1 && (data & 0x80)) if (floppy[dr].indexhackmode > 1 && (data & 0x80))
floppy[dr].indexhack = 1; floppy[dr].indexhack = 1;
} }
} }
} }
} }
if (!savestate_state) { if (!savestate_state) {
for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) { for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) {
drive *drv = floppy + dr; drive* drv = floppy + dr;
/* motor on/off workings tested with small assembler code on real Amiga 1200. */ /* motor on/off workings tested with small assembler code on real Amiga 1200. */
/* motor/id flipflop is set only when drive select goes from high to low */ /* motor/id flipflop is set only when drive select goes from high to low */
if (!((selected | disabled) & (1 << dr)) && (prev_selected & (1 << dr)) ) { if (!((selected | disabled) & (1 << dr)) && (prev_selected & (1 << dr))) {
drv->drive_id_scnt++; drv->drive_id_scnt++;
drv->drive_id_scnt &= 31; drv->drive_id_scnt &= 31;
drv->idbit = (drv->drive_id & (1L << (31 - drv->drive_id_scnt))) ? 1 : 0; drv->idbit = (drv->drive_id & (1L << (31 - drv->drive_id_scnt))) ? 1 : 0;
if (!(disabled & (1 << dr))) { if (!(disabled & (1 << dr))) {
if ((prev_data & 0x80) == 0 || (data & 0x80) == 0) { if ((prev_data & 0x80) == 0 || (data & 0x80) == 0) {
/* motor off: if motor bit = 0 in prevdata or data -> turn motor on */ /* motor off: if motor bit = 0 in prevdata or data -> turn motor on */
drive_motor (drv, 0); drive_motor(drv, 0);
} else if (prev_data & 0x80) { }
/* motor on: if motor bit = 1 in prevdata only (motor flag state in data has no effect) else if (prev_data & 0x80) {
-> turn motor off */ /* motor on: if motor bit = 1 in prevdata only (motor flag state in data has no effect)
drive_motor (drv, 1); -> turn motor off */
} drive_motor(drv, 1);
} }
}
if (!currprefs.cs_df0idhw && dr == 0) if (!currprefs.cs_df0idhw && dr == 0)
drv->idbit = 0; drv->idbit = 0;
} }
} }
} }
for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) { for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) {
// selected // selected
if (!(selected & (1 << dr)) && floppy[dr].selected_delay < 0) { if (!(selected & (1 << dr)) && floppy[dr].selected_delay < 0) {
floppy[dr].selected_delay = 2; floppy[dr].selected_delay = 2;
@ -2731,49 +2736,52 @@ void DISK_select (uae_u8 data)
// external drives usually (always?) light activity led when selected. Internal only when motor is running. // external drives usually (always?) light activity led when selected. Internal only when motor is running.
bool selected_led = !(selected & (1 << dr)) && floppy[dr].selected_delay == 0 && dr > 0; bool selected_led = !(selected & (1 << dr)) && floppy[dr].selected_delay == 0 && dr > 0;
floppy[dr].state = selected_led || !floppy[dr].motoroff; floppy[dr].state = selected_led || !floppy[dr].motoroff;
update_drive_gui (dr, false); update_drive_gui(dr, false);
} }
prev_data = data; prev_data = data;
} }
uae_u8 DISK_status_ciaa(void) uae_u8 DISK_status_ciaa(void)
{ {
uae_u8 st = 0x3c; uae_u8 st = 0x3c;
for (int dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) { for (int dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) {
drive *drv = floppy + dr; drive* drv = floppy + dr;
if (!((selected | disabled) & (1 << dr))) { if (!((selected | disabled) & (1 << dr))) {
if (drive_running (drv)) { if (drive_running(drv)) {
if (drv->dskready && !drv->indexhack && currprefs.floppyslots[dr].dfxtype != DRV_35_DD_ESCOM) if (drv->dskready && !drv->indexhack && currprefs.floppyslots[dr].dfxtype != DRV_35_DD_ESCOM)
st &= ~0x20; st &= ~0x20;
} else { }
else {
if (currprefs.cs_df0idhw || dr > 0) { if (currprefs.cs_df0idhw || dr > 0) {
/* report drive ID */ /* report drive ID */
if (drv->idbit && currprefs.floppyslots[dr].dfxtype != DRV_35_DD_ESCOM) if (drv->idbit && currprefs.floppyslots[dr].dfxtype != DRV_35_DD_ESCOM)
st &= ~0x20; st &= ~0x20;
} else { }
/* non-ID internal drive: mirror real dskready */ else {
if (drv->dskready) /* non-ID internal drive: mirror real dskready */
st &= ~0x20; if (drv->dskready)
} st &= ~0x20;
/* dskrdy needs some cycles after switching the motor off.. (Pro Tennis Tour) */ }
/* dskrdy needs some cycles after switching the motor off.. (Pro Tennis Tour) */
if (!currprefs.cs_df0idhw && dr == 0 && drv->motordelay) if (!currprefs.cs_df0idhw && dr == 0 && drv->motordelay)
st &= ~0x20; st &= ~0x20;
} }
if (drive_track0 (drv)) if (drive_track0(drv))
st &= ~0x10; st &= ~0x10;
if (drive_writeprotected (drv)) if (drive_writeprotected(drv))
st &= ~8; st &= ~8;
if (drv->dskchange && currprefs.floppyslots[dr].dfxtype != DRV_525_SD) { if (drv->dskchange && currprefs.floppyslots[dr].dfxtype != DRV_525_SD) {
st &= ~4; st &= ~4;
} }
} else if (!((selected | disabled) & (1 << dr))) { }
if (drv->idbit) else if (!((selected | disabled) & (1 << dr))) {
st &= ~0x20; if (drv->idbit)
} st &= ~0x20;
} }
}
return st; return st;
} }
static bool unformatted (drive *drv) static bool unformatted (drive *drv)
@ -3252,21 +3260,21 @@ static void DISK_start (void)
static int linecounter; static int linecounter;
void DISK_hsync (void) void DISK_hsync(void)
{ {
int dr; int dr;
for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) { for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) {
drive *drv = &floppy[dr]; drive* drv = &floppy[dr];
if (drv->steplimit) if (drv->steplimit)
drv->steplimit--; drv->steplimit--;
if (drv->revolution_check) if (drv->revolution_check)
drv->revolution_check--; drv->revolution_check--;
if (drv->dskready_down_time > 0) if (drv->dskready_down_time > 0)
drv->dskready_down_time--; drv->dskready_down_time--;
/* emulate drive motor turn on time */ /* emulate drive motor turn on time */
if (drv->dskready_up_time > 0 && !drive_empty (drv)) { if (drv->dskready_up_time > 0 && !drive_empty(drv)) {
drv->dskready_up_time--; drv->dskready_up_time--;
if (drv->dskready_up_time == 0 && !drv->motoroff) if (drv->dskready_up_time == 0 && !drv->motoroff)
drv->dskready = true; drv->dskready = true;
@ -3275,20 +3283,20 @@ void DISK_hsync (void)
if (drv->dskchange_time > 0) { if (drv->dskchange_time > 0) {
drv->dskchange_time--; drv->dskchange_time--;
if (drv->dskchange_time == 0) { if (drv->dskchange_time == 0) {
drive_insert (drv, &currprefs, dr, drv->newname, false, drv->newnamewriteprotected); drive_insert(drv, &currprefs, dr, drv->newname, false, drv->newnamewriteprotected);
update_drive_gui (dr, false); update_drive_gui(dr, false);
} }
} }
} }
if (indexdecay) if (indexdecay)
indexdecay--; indexdecay--;
if (linecounter) { if (linecounter) {
linecounter--; linecounter--;
if (! linecounter) if (!linecounter)
disk_dmafinished (); disk_dmafinished();
return; return;
} }
DISK_update (maxhpos); DISK_update(maxhpos);
} }
void DISK_update (int tohpos) void DISK_update (int tohpos)