80486DX2-66/86Box-fork
1
0
Fork 0
Code Issues Pull Requests Activity

More linting in src/disk

Browse Source
This commit is contained in:
Jasmine Iwanek
2023-08-21 20:22:55 -04:00
parent 532f8ca91f
commit 7342c0a77a
10 changed files with 149 additions and 152 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/disk/hdc.c
View File

@@ -142,7 +142,7 @@ hdc_reset(void)
device_add(&ide_qua_device);
}
char *
const char *
hdc_get_internal_name(int hdc)
{
return device_get_internal_name(controllers[hdc].device);
@@ -154,7 +154,7 @@ hdc_get_from_internal_name(char *s)
int c = 0;
while (controllers[c].device != NULL) {
if (!strcmp((char *) controllers[c].device->internal_name, s))
if (!strcmp(controllers[c].device->internal_name, s))
return c;
c++;
}

2
src/disk/hdc_esdi_at.c
View File

@@ -789,7 +789,7 @@ esdi_callback(void *priv)
default:
esdi_at_log("WD1007: callback on unknown command %02x\n", esdi->command);
/*FALLTHROUGH*/
fallthrough;
case 0xe8:
esdi->status = STAT_READY | STAT_ERR | STAT_DSC;

2
src/disk/hdc_ide.c
View File

@@ -1279,7 +1279,7 @@ ide_write_data(ide_t *ide, uint32_t val, int length)
void
ide_writew(uint16_t addr, uint16_t val, void *priv)
{
ide_board_t *dev = (ide_board_t *) priv;
const ide_board_t *dev = (ide_board_t *) priv;
ide_t *ide;
int ch;

8
src/disk/hdc_st506_xt.c
View File

@@ -1573,10 +1573,10 @@ set_switches(hdc_t *dev, hd_type_t *hdt, int num)
static void *
st506_init(const device_t *info)
{
char *fn = NULL;
hdc_t *dev;
int i;
int c;
const char *fn = NULL;
hdc_t *dev;
int i;
int c;
dev = (hdc_t *) malloc(sizeof(hdc_t));
memset(dev, 0x00, sizeof(hdc_t));

28
src/disk/hdc_xta.c
View File

@@ -432,13 +432,13 @@ do_fmt:
static void
hdc_callback(void *priv)
{
hdc_t *dev = (hdc_t *) priv;
dcb_t *dcb = &dev->dcb;
drive_t *drive;
dprm_t *params;
off64_t addr;
int no_data = 0;
int val;
hdc_t *dev = (hdc_t *) priv;
dcb_t *dcb = &dev->dcb;
drive_t *drive;
const dprm_t *params;
off64_t addr;
int no_data = 0;
int val;
drive = &dev->drives[dcb->drvsel];
dev->comp = (dcb->drvsel) ? COMP_DRIVE : 0x00;
@@ -983,12 +983,12 @@ hdc_write(uint16_t port, uint8_t val, void *priv)
static void *
xta_init(const device_t *info)
{
drive_t *drive;
char *bios_rev = NULL;
char *fn = NULL;
hdc_t *dev;
int c;
int max = XTA_NUM;
drive_t *drive;
const char *bios_rev = NULL;
const char *fn = NULL;
hdc_t *dev;
int c;
int max = XTA_NUM;
/* Allocate and initialize device block. */
dev = malloc(sizeof(hdc_t));
@@ -1004,7 +1004,7 @@ xta_init(const device_t *info)
dev->rom_addr = device_get_config_hex20("bios_addr");
dev->dma = 3;
bios_rev = (char *) device_get_config_bios("bios_rev");
fn = (char *) device_get_bios_file(info, (const char *) bios_rev, 0);
fn = (char *) device_get_bios_file(info, bios_rev, 0);
max = 1;
break;

2
src/disk/hdd.c
View File

@@ -461,7 +461,7 @@ hdd_preset_get_from_internal_name(char *s)
int c = 0;
for (int i = 0; i < (sizeof(hdd_speed_presets) / sizeof(hdd_preset_t)); i++) {
if (!strcmp((char *) hdd_speed_presets[c].internal_name, s))
if (!strcmp(hdd_speed_presets[c].internal_name, s))
return c;
c++;
}

30
src/disk/hdd_image.c
View File

@@ -85,28 +85,28 @@ image_is_hdi(const char *s)
int
image_is_hdx(const char *s, int check_signature)
{
FILE *f;
FILE *fp;
uint64_t filelen;
uint64_t signature;
if (!strcasecmp(path_get_extension((char *) s), "HDX")) {
if (check_signature) {
f = plat_fopen(s, "rb");
if (!f)
fp = plat_fopen(s, "rb");
if (!fp)
return 0;
if (fseeko64(f, 0, SEEK_END))
if (fseeko64(fp, 0, SEEK_END))
fatal("image_is_hdx(): Error while seeking");
filelen = ftello64(f);
if (fseeko64(f, 0, SEEK_SET))
filelen = ftello64(fp);
if (fseeko64(fp, 0, SEEK_SET))
fatal("image_is_hdx(): Error while seeking");
if (filelen < 44) {
if (f != NULL)
fclose(f);
if (fp != NULL)
fclose(fp);
return 0;
}
if (fread(&signature, 1, 8, f) != 8)
if (fread(&signature, 1, 8, fp) != 8)
fatal("image_is_hdx(): Error reading signature\n");
fclose(f);
fclose(fp);
if (signature == 0xD778A82044445459LL)
return 1;
else
@@ -120,16 +120,16 @@ image_is_hdx(const char *s, int check_signature)
int
image_is_vhd(const char *s, int check_signature)
{
FILE *f;
FILE *fp;
if (!strcasecmp(path_get_extension((char *) s), "VHD")) {
if (check_signature) {
f = plat_fopen(s, "rb");
if (!f)
fp = plat_fopen(s, "rb");
if (!fp)
return 0;
bool is_vhd = mvhd_file_is_vhd(f);
fclose(f);
bool is_vhd = mvhd_file_is_vhd(fp);
fclose(fp);
return is_vhd ? 1 : 0;
} else
return 1;

52
src/disk/minivhd/create.c
View File

@@ -245,11 +245,11 @@ mvhd_create_fixed_raw(const char* path, FILE* raw_img, uint64_t size_in_bytes, M
goto end;
}
FILE* f = mvhd_fopen(path, "wb+", err);
if (f == NULL) {
FILE* fp = mvhd_fopen(path, "wb+", err);
if (fp == NULL) {
goto cleanup_vhdm;
}
mvhd_fseeko64(f, 0, SEEK_SET);
mvhd_fseeko64(fp, 0, SEEK_SET);
uint32_t size_sectors = (uint32_t)(size_in_bytes / MVHD_SECTOR_SIZE);
uint32_t s;
@@ -269,22 +269,22 @@ mvhd_create_fixed_raw(const char* path, FILE* raw_img, uint64_t size_in_bytes, M
mvhd_fseeko64(raw_img, 0, SEEK_SET);
for (s = 0; s < size_sectors; s++) {
(void) !fread(img_data, sizeof img_data, 1, raw_img);
fwrite(img_data, sizeof img_data, 1, f);
fwrite(img_data, sizeof img_data, 1, fp);
if (progress_callback)
progress_callback(s + 1, size_sectors);
}
} else {
gen_footer(&vhdm->footer, size_in_bytes, geom, MVHD_TYPE_FIXED, 0);
for (s = 0; s < size_sectors; s++) {
fwrite(img_data, sizeof img_data, 1, f);
fwrite(img_data, sizeof img_data, 1, fp);
if (progress_callback)
progress_callback(s + 1, size_sectors);
}
}
mvhd_footer_to_buffer(&vhdm->footer, footer_buff);
fwrite(footer_buff, sizeof footer_buff, 1, f);
fclose(f);
f = NULL;
fwrite(footer_buff, sizeof footer_buff, 1, fp);
fclose(fp);
fp = NULL;
free(vhdm);
vhdm = mvhd_open(path, false, err);
goto end;
@@ -352,11 +352,11 @@ create_sparse_diff(const char* path, const char* par_path, uint64_t size_in_byte
goto cleanup_vhdm;
}
FILE* f = mvhd_fopen(path, "wb+", err);
if (f == NULL) {
FILE* fp = mvhd_fopen(path, "wb+", err);
if (fp == NULL) {
goto cleanup_vhdm;
}
mvhd_fseeko64(f, 0, SEEK_SET);
mvhd_fseeko64(fp, 0, SEEK_SET);
/* Note, the sparse header follows the footer copy at the beginning of the file */
if (par_path == NULL) {
@@ -367,7 +367,7 @@ create_sparse_diff(const char* path, const char* par_path, uint64_t size_in_byte
mvhd_footer_to_buffer(&vhdm->footer, footer_buff);
/* As mentioned, start with a copy of the footer */
fwrite(footer_buff, sizeof footer_buff, 1, f);
fwrite(footer_buff, sizeof footer_buff, 1, fp);
/**
* Calculate the number of (2MB or 512KB) data blocks required to store the entire
@@ -417,20 +417,20 @@ create_sparse_diff(const char* path, const char* par_path, uint64_t size_in_byte
}
gen_sparse_header(&vhdm->sparse, num_blks, bat_offset, block_size_in_sectors);
mvhd_header_to_buffer(&vhdm->sparse, sparse_buff);
fwrite(sparse_buff, sizeof sparse_buff, 1, f);
fwrite(sparse_buff, sizeof sparse_buff, 1, fp);
/* The BAT sectors need to be filled with 0xffffffff */
for (uint32_t k = 0; k < num_bat_sect; k++) {
fwrite(bat_sect, sizeof bat_sect, 1, f);
fwrite(bat_sect, sizeof bat_sect, 1, fp);
}
mvhd_write_empty_sectors(f, 5);
mvhd_write_empty_sectors(fp, 5);
/**
* If creating a differencing VHD, the paths to the parent image need to be written
* tp the file. Both absolute and relative paths are written
* */
if (par_vhdm != NULL) {
uint64_t curr_pos = (uint64_t)mvhd_ftello64(f);
uint64_t curr_pos = (uint64_t)mvhd_ftello64(fp);
/* Double check my sums... */
assert(curr_pos == par_loc_offset);
@@ -440,25 +440,25 @@ create_sparse_diff(const char* path, const char* par_path, uint64_t size_in_byte
for (int i = 0; i < 2; i++) {
for (uint32_t j = 0; j < (vhdm->sparse.par_loc_entry[i].plat_data_space / MVHD_SECTOR_SIZE); j++) {
fwrite(empty_sect, sizeof empty_sect, 1, f);
fwrite(empty_sect, sizeof empty_sect, 1, fp);
}
}
/* Now write the location entries */
mvhd_fseeko64(f, vhdm->sparse.par_loc_entry[0].plat_data_offset, SEEK_SET);
fwrite(w2ku_path_buff, vhdm->sparse.par_loc_entry[0].plat_data_len, 1, f);
mvhd_fseeko64(f, vhdm->sparse.par_loc_entry[1].plat_data_offset, SEEK_SET);
fwrite(w2ru_path_buff, vhdm->sparse.par_loc_entry[1].plat_data_len, 1, f);
mvhd_fseeko64(fp, vhdm->sparse.par_loc_entry[0].plat_data_offset, SEEK_SET);
fwrite(w2ku_path_buff, vhdm->sparse.par_loc_entry[0].plat_data_len, 1, fp);
mvhd_fseeko64(fp, vhdm->sparse.par_loc_entry[1].plat_data_offset, SEEK_SET);
fwrite(w2ru_path_buff, vhdm->sparse.par_loc_entry[1].plat_data_len, 1, fp);
/* and reset the file position to continue */
mvhd_fseeko64(f, vhdm->sparse.par_loc_entry[1].plat_data_offset + vhdm->sparse.par_loc_entry[1].plat_data_space, SEEK_SET);
mvhd_write_empty_sectors(f, 5);
mvhd_fseeko64(fp, vhdm->sparse.par_loc_entry[1].plat_data_offset + vhdm->sparse.par_loc_entry[1].plat_data_space, SEEK_SET);
mvhd_write_empty_sectors(fp, 5);
}
/* And finish with the footer */
fwrite(footer_buff, sizeof footer_buff, 1, f);
fclose(f);
f = NULL;
fwrite(footer_buff, sizeof footer_buff, 1, fp);
fclose(fp);
fp = NULL;
free(vhdm);
vhdm = mvhd_open(path, false, err);
goto end;

89
src/disk/mo.c
View File

@@ -316,9 +316,9 @@ find_mo_for_channel(uint8_t channel)
static int
mo_load_abort(mo_t *dev)
{
if (dev->drv->f)
fclose(dev->drv->f);
dev->drv->f = NULL;
if (dev->drv->fp)
fclose(dev->drv->fp);
dev->drv->fp = NULL;
dev->drv->medium_size = 0;
dev->drv->sector_size = 0;
mo_eject(dev->id); /* Make sure the host OS knows we've rejected (and ejected) the image. */
@@ -343,11 +343,11 @@ mo_load(mo_t *dev, char *fn)
is_mdi = image_is_mdi(fn);
dev->drv->f = plat_fopen(fn, dev->drv->read_only ? "rb" : "rb+");
if (!dev->drv->f) {
dev->drv->fp = plat_fopen(fn, dev->drv->read_only ? "rb" : "rb+");
if (!dev->drv->fp) {
if (!dev->drv->read_only) {
dev->drv->f = plat_fopen(fn, "rb");
if (dev->drv->f)
dev->drv->fp = plat_fopen(fn, "rb");
if (dev->drv->fp)
dev->drv->read_only = 1;
else
return mo_load_abort(dev);
@@ -355,8 +355,8 @@ mo_load(mo_t *dev, char *fn)
return mo_load_abort(dev);
}
fseek(dev->drv->f, 0, SEEK_END);
size = (uint32_t) ftell(dev->drv->f);
fseek(dev->drv->fp, 0, SEEK_END);
size = (uint32_t) ftell(dev->drv->fp);
if (is_mdi) {
/* This is a MDI image. */
@@ -376,7 +376,7 @@ mo_load(mo_t *dev, char *fn)
if (!found)
return mo_load_abort(dev);
if (fseek(dev->drv->f, dev->drv->base, SEEK_SET) == -1)
if (fseek(dev->drv->fp, dev->drv->base, SEEK_SET) == -1)
fatal("mo_load(): Error seeking to the beginning of the file\n");
strncpy(dev->drv->image_path, fn, sizeof(dev->drv->image_path) - 1);
@@ -401,16 +401,16 @@ mo_disk_reload(mo_t *dev)
void
mo_disk_unload(mo_t *dev)
{
if (dev->drv->f) {
fclose(dev->drv->f);
dev->drv->f = NULL;
if (dev->drv->fp) {
fclose(dev->drv->fp);
dev->drv->fp = NULL;
}
}
void
mo_disk_close(mo_t *dev)
{
if (dev->drv->f) {
if (dev->drv->fp) {
mo_disk_unload(dev);
memcpy(dev->drv->prev_image_path, dev->drv->image_path, sizeof(dev->drv->prev_image_path));
@@ -515,8 +515,8 @@ mo_atapi_phase_to_scsi(mo_t *dev)
static void
mo_mode_sense_load(mo_t *dev)
{
FILE *f;
char file_name[512];
FILE *fp;
char fn[512];
memset(&dev->ms_pages_saved, 0, sizeof(mode_sense_pages_t));
if (mo_drives[dev->id].bus_type == MO_BUS_SCSI)
@@ -524,33 +524,33 @@ mo_mode_sense_load(mo_t *dev)
else
memcpy(&dev->ms_pages_saved, &mo_mode_sense_pages_default, sizeof(mode_sense_pages_t));
memset(file_name, 0, 512);
memset(fn, 0, 512);
if (dev->drv->bus_type == MO_BUS_SCSI)
sprintf(file_name, "scsi_mo_%02i_mode_sense_bin", dev->id);
sprintf(fn, "scsi_mo_%02i_mode_sense_bin", dev->id);
else
sprintf(file_name, "mo_%02i_mode_sense_bin", dev->id);
f = plat_fopen(nvr_path(file_name), "rb");
if (f) {
sprintf(fn, "mo_%02i_mode_sense_bin", dev->id);
fp = plat_fopen(nvr_path(fn), "rb");
if (fp) {
/* Nothing to read, not used by MO. */
fclose(f);
fclose(fp);
}
}
static void
mo_mode_sense_save(mo_t *dev)
{
FILE *f;
char file_name[512];
FILE *fp;
char fn[512];
memset(file_name, 0, 512);
memset(fn, 0, 512);
if (dev->drv->bus_type == MO_BUS_SCSI)
sprintf(file_name, "scsi_mo_%02i_mode_sense_bin", dev->id);
sprintf(fn, "scsi_mo_%02i_mode_sense_bin", dev->id);
else
sprintf(file_name, "mo_%02i_mode_sense_bin", dev->id);
f = plat_fopen(nvr_path(file_name), "wb");
if (f) {
sprintf(fn, "mo_%02i_mode_sense_bin", dev->id);
fp = plat_fopen(nvr_path(fn), "wb");
if (fp) {
/* Nothing to write, not used by MO. */
fclose(f);
fclose(fp);
}
}
@@ -562,16 +562,13 @@ mo_mode_sense_read(mo_t *dev, uint8_t page_control, uint8_t page, uint8_t pos)
case 0:
case 3:
return dev->ms_pages_saved.pages[page][pos];
break;
case 1:
return mo_mode_sense_pages_changeable.pages[page][pos];
break;
case 2:
if (dev->drv->bus_type == MO_BUS_SCSI)
return mo_mode_sense_pages_default_scsi.pages[page][pos];
else
return mo_mode_sense_pages_default.pages[page][pos];
break;
default:
break;
@@ -965,17 +962,17 @@ mo_blocks(mo_t *dev, int32_t *len, UNUSED(int first_batch), int out)
*len = dev->requested_blocks * dev->drv->sector_size;
for (int i = 0; i < dev->requested_blocks; i++) {
if (fseek(dev->drv->f, dev->drv->base + (dev->sector_pos * dev->drv->sector_size) + (i * dev->drv->sector_size), SEEK_SET) == 1)
if (fseek(dev->drv->fp, dev->drv->base + (dev->sector_pos * dev->drv->sector_size) + (i * dev->drv->sector_size), SEEK_SET) == 1)
break;
if (feof(dev->drv->f))
if (feof(dev->drv->fp))
break;
if (out) {
if (fwrite(dev->buffer + (i * dev->drv->sector_size), 1, dev->drv->sector_size, dev->drv->f) != dev->drv->sector_size)
if (fwrite(dev->buffer + (i * dev->drv->sector_size), 1, dev->drv->sector_size, dev->drv->fp) != dev->drv->sector_size)
fatal("mo_blocks(): Error writing data\n");
} else {
if (fread(dev->buffer + (i * dev->drv->sector_size), 1, dev->drv->sector_size, dev->drv->f) != dev->drv->sector_size)
if (fread(dev->buffer + (i * dev->drv->sector_size), 1, dev->drv->sector_size, dev->drv->fp) != dev->drv->sector_size)
fatal("mo_blocks(): Error reading data\n");
}
}
@@ -1003,14 +1000,14 @@ mo_format(mo_t *dev)
mo_log("MO %i: Formatting media...\n", dev->id);
fseek(dev->drv->f, 0, SEEK_END);
size = ftell(dev->drv->f);
fseek(dev->drv->fp, 0, SEEK_END);
size = ftell(dev->drv->fp);
#ifdef _WIN32
HANDLE fh;
LARGE_INTEGER liSize;
fd = _fileno(dev->drv->f);
fd = _fileno(dev->drv->fp);
fh = (HANDLE) _get_osfhandle(fd);
liSize.QuadPart = 0;
@@ -1044,7 +1041,7 @@ mo_format(mo_t *dev)
return;
}
#else
fd = fileno(dev->drv->f);
fd = fileno(dev->drv->fp);
ret = ftruncate(fd, 0);
@@ -1083,13 +1080,13 @@ mo_erase(mo_t *dev)
mo_buf_alloc(dev, dev->drv->sector_size);
memset(dev->buffer, 0, dev->drv->sector_size);
fseek(dev->drv->f, dev->drv->base + (dev->sector_pos * dev->drv->sector_size), SEEK_SET);
fseek(dev->drv->fp, dev->drv->base + (dev->sector_pos * dev->drv->sector_size), SEEK_SET);
for (i = 0; i < dev->requested_blocks; i++) {
if (feof(dev->drv->f))
if (feof(dev->drv->fp))
break;
fwrite(dev->buffer, 1, dev->drv->sector_size, dev->drv->f);
fwrite(dev->buffer, 1, dev->drv->sector_size, dev->drv->fp);
}
mo_log("MO %i: Erased %i bytes of blocks...\n", dev->id, i * dev->drv->sector_size);
@@ -1140,7 +1137,7 @@ mo_pre_execution_check(mo_t *dev, uint8_t *cdb)
return 0;
}
ready = (dev->drv->f != NULL);
ready = (dev->drv->fp != NULL);
/* If the drive is not ready, there is no reason to keep the
UNIT ATTENTION condition present, as we only use it to mark
@@ -1256,7 +1253,7 @@ mo_request_sense_for_scsi(scsi_common_t *sc, uint8_t *buffer, uint8_t alloc_leng
mo_t *dev = (mo_t *) sc;
int ready = 0;
ready = (dev->drv->f != NULL);
ready = (dev->drv->fp != NULL);
if (!ready && dev->unit_attention) {
/* If the drive is not ready, there is no reason to keep the

84
src/disk/zip.c
View File

@@ -470,9 +470,9 @@ find_zip_for_channel(uint8_t channel)
static int
zip_load_abort(zip_t *dev)
{
if (dev->drv->f)
fclose(dev->drv->f);
dev->drv->f = NULL;
if (dev->drv->fp)
fclose(dev->drv->fp);
dev->drv->fp = NULL;
dev->drv->medium_size = 0;
zip_eject(dev->id); /* Make sure the host OS knows we've rejected (and ejected) the image. */
return 0;
@@ -483,11 +483,11 @@ zip_load(zip_t *dev, char *fn)
{
int size = 0;
dev->drv->f = plat_fopen(fn, dev->drv->read_only ? "rb" : "rb+");
if (!dev->drv->f) {
dev->drv->fp = plat_fopen(fn, dev->drv->read_only ? "rb" : "rb+");
if (!dev->drv->fp) {
if (!dev->drv->read_only) {
dev->drv->f = plat_fopen(fn, "rb");
if (dev->drv->f)
dev->drv->fp = plat_fopen(fn, "rb");
if (dev->drv->fp)
dev->drv->read_only = 1;
else
return zip_load_abort(dev);
@@ -495,8 +495,8 @@ zip_load(zip_t *dev, char *fn)
return zip_load_abort(dev);
}
fseek(dev->drv->f, 0, SEEK_END);
size = ftell(dev->drv->f);
fseek(dev->drv->fp, 0, SEEK_END);
size = ftell(dev->drv->fp);
if ((size == ((ZIP_250_SECTORS << 9) + 0x1000)) || (size == ((ZIP_SECTORS << 9) + 0x1000))) {
/* This is a ZDI image. */
@@ -521,7 +521,7 @@ zip_load(zip_t *dev, char *fn)
dev->drv->medium_size = size >> 9;
if (fseek(dev->drv->f, dev->drv->base, SEEK_SET) == -1)
if (fseek(dev->drv->fp, dev->drv->base, SEEK_SET) == -1)
fatal("zip_load(): Error seeking to the beginning of the file\n");
strncpy(dev->drv->image_path, fn, sizeof(dev->drv->image_path) - 1);
@@ -546,16 +546,16 @@ zip_disk_reload(zip_t *dev)
void
zip_disk_unload(zip_t *dev)
{
if (dev->drv->f) {
fclose(dev->drv->f);
dev->drv->f = NULL;
if (dev->drv->fp) {
fclose(dev->drv->fp);
dev->drv->fp = NULL;
}
}
void
zip_disk_close(zip_t *dev)
{
if (dev->drv->f) {
if (dev->drv->fp) {
zip_disk_unload(dev);
memcpy(dev->drv->prev_image_path, dev->drv->image_path, sizeof(dev->drv->prev_image_path));
@@ -660,8 +660,8 @@ zip_atapi_phase_to_scsi(zip_t *dev)
static void
zip_mode_sense_load(zip_t *dev)
{
FILE *f;
char file_name[512];
FILE *fp;
char fn[512];
memset(&dev->ms_pages_saved, 0, sizeof(mode_sense_pages_t));
if (dev->drv->is_250) {
@@ -676,33 +676,33 @@ zip_mode_sense_load(zip_t *dev)
memcpy(&dev->ms_pages_saved, &zip_mode_sense_pages_default, sizeof(mode_sense_pages_t));
}
memset(file_name, 0, 512);
memset(fn, 0, 512);
if (dev->drv->bus_type == ZIP_BUS_SCSI)
sprintf(file_name, "scsi_zip_%02i_mode_sense_bin", dev->id);
sprintf(fn, "scsi_zip_%02i_mode_sense_bin", dev->id);
else
sprintf(file_name, "zip_%02i_mode_sense_bin", dev->id);
f = plat_fopen(nvr_path(file_name), "rb");
if (f) {
sprintf(fn, "zip_%02i_mode_sense_bin", dev->id);
fp = plat_fopen(nvr_path(fn), "rb");
if (fp) {
/* Nothing to read, not used by ZIP. */
fclose(f);
fclose(fp);
}
}
static void
zip_mode_sense_save(zip_t *dev)
{
FILE *f;
char file_name[512];
FILE *fp;
char fn[512];
memset(file_name, 0, 512);
memset(fn, 0, 512);
if (dev->drv->bus_type == ZIP_BUS_SCSI)
sprintf(file_name, "scsi_zip_%02i_mode_sense_bin", dev->id);
sprintf(fn, "scsi_zip_%02i_mode_sense_bin", dev->id);
else
sprintf(file_name, "zip_%02i_mode_sense_bin", dev->id);
f = plat_fopen(nvr_path(file_name), "wb");
if (f) {
sprintf(fn, "zip_%02i_mode_sense_bin", dev->id);
fp = plat_fopen(nvr_path(fn), "wb");
if (fp) {
/* Nothing to write, not used by ZIP. */
fclose(f);
fclose(fp);
}
}
@@ -1140,17 +1140,17 @@ zip_blocks(zip_t *dev, int32_t *len, UNUSED(int first_batch), int out)
*len = dev->requested_blocks << 9;
for (int i = 0; i < dev->requested_blocks; i++) {
if (fseek(dev->drv->f, dev->drv->base + (dev->sector_pos << 9) + (i << 9), SEEK_SET) == 1)
if (fseek(dev->drv->fp, dev->drv->base + (dev->sector_pos << 9) + (i << 9), SEEK_SET) == 1)
break;
if (feof(dev->drv->f))
if (feof(dev->drv->fp))
break;
if (out) {
if (fwrite(dev->buffer + (i << 9), 1, 512, dev->drv->f) != 512)
if (fwrite(dev->buffer + (i << 9), 1, 512, dev->drv->fp) != 512)
fatal("zip_blocks(): Error writing data\n");
} else {
if (fread(dev->buffer + (i << 9), 1, 512, dev->drv->f) != 512)
if (fread(dev->buffer + (i << 9), 1, 512, dev->drv->fp) != 512)
fatal("zip_blocks(): Error reading data\n");
}
}
@@ -1209,7 +1209,7 @@ zip_pre_execution_check(zip_t *dev, uint8_t *cdb)
return 0;
}
ready = (dev->drv->f != NULL);
ready = (dev->drv->fp != NULL);
/* If the drive is not ready, there is no reason to keep the
UNIT ATTENTION condition present, as we only use it to mark
@@ -1325,7 +1325,7 @@ zip_request_sense_for_scsi(scsi_common_t *sc, uint8_t *buffer, uint8_t alloc_len
zip_t *dev = (zip_t *) sc;
int ready = 0;
ready = (dev->drv->f != NULL);
ready = (dev->drv->fp != NULL);
if (!ready && dev->unit_attention) {
/* If the drive is not ready, there is no reason to keep the
@@ -1972,7 +1972,7 @@ atapi_out:
dev->buffer[pos++] = 0;
dev->buffer[pos++] = 0;
dev->buffer[pos++] = 0;
if (dev->drv->f != NULL)
if (dev->drv->fp != NULL)
dev->buffer[pos++] = 16;
else
dev->buffer[pos++] = 8;
@@ -1981,7 +1981,7 @@ atapi_out:
if (dev->drv->is_250) {
/* ZIP 250 also supports ZIP 100 media, so if the medium is inserted,
we return the inserted medium's size, otherwise, the ZIP 250 size. */
if (dev->drv->f != NULL) {
if (dev->drv->fp != NULL) {
dev->buffer[pos++] = (dev->drv->medium_size >> 24) & 0xff;
dev->buffer[pos++] = (dev->drv->medium_size >> 16) & 0xff;
dev->buffer[pos++] = (dev->drv->medium_size >> 8) & 0xff;
@@ -2001,7 +2001,7 @@ atapi_out:
dev->buffer[pos++] = (ZIP_SECTORS >> 16) & 0xff;
dev->buffer[pos++] = (ZIP_SECTORS >> 8) & 0xff;
dev->buffer[pos++] = ZIP_SECTORS & 0xff;
if (dev->drv->f != NULL)
if (dev->drv->fp != NULL)
dev->buffer[pos++] = 2;
else
dev->buffer[pos++] = 3;
@@ -2011,7 +2011,7 @@ atapi_out:
dev->buffer[pos++] = 512 >> 8;
dev->buffer[pos++] = 512 & 0xff;
if (dev->drv->f != NULL) {
if (dev->drv->fp != NULL) {
/* Formattable capacity descriptor */
dev->buffer[pos++] = (dev->drv->medium_size >> 24) & 0xff;
dev->buffer[pos++] = (dev->drv->medium_size >> 16) & 0xff;
@@ -2117,9 +2117,9 @@ zip_phase_data_out(scsi_common_t *sc)
dev->buffer[6] = (s >> 8) & 0xff;
dev->buffer[7] = s & 0xff;
}
if (fseek(dev->drv->f, dev->drv->base + (i << 9), SEEK_SET) == -1)
if (fseek(dev->drv->fp, dev->drv->base + (i << 9), SEEK_SET) == -1)
fatal("zip_phase_data_out(): Error seeking\n");
if (fwrite(dev->buffer, 1, 512, dev->drv->f) != 512)
if (fwrite(dev->buffer, 1, 512, dev->drv->fp) != 512)
fatal("zip_phase_data_out(): Error writing data\n");
}
break;