rc759: Use the pri block device to load pri images

Makefile.dep

···
 	src/arch/rc759/main.h \
 	src/chipset/wd179x.h \
 	src/config.h \
+	src/drivers/block/blkpri.h \
 	src/drivers/block/blkpsi.h \
 	src/drivers/block/block.h \
 	src/drivers/pri/pri-enc-mfm.h \

src/arch/rc759/fdc.c

···
 /*****************************************************************************
  * File name:   src/arch/rc759/fdc.c                                         *
  * Created:     2012-07-05 by Hampa Hug <[e-mail]>                     *
- * Copyright:   (C) 2012-2014 Hampa Hug <[e-mail]>                     *
+ * Copyright:   (C) 2012-2019 Hampa Hug <[e-mail]>                     *
  *****************************************************************************/
 
 /*****************************************************************************
···
 #include <chipset/wd179x.h>
 
 #include <drivers/block/block.h>
+#include <drivers/block/blkpri.h>
 #include <drivers/block/blkpsi.h>
 
 #include <drivers/psi/psi.h>
···
 	fdc->fcr = 0;
 
 	for (i = 0; i < 2; i++) {
-		fdc->use_fname[i] = 0;
-		fdc->fname[i] = NULL;
 		fdc->diskid[i] = 0xffff;
 		fdc->img[i] = NULL;
+		fdc->img_del[i] = 0;
 		fdc->modified[i] = 0;
 	}
 }
···
 	for (i = 0; i < 2; i++) {
 		rc759_fdc_save (fdc, i);
 
-		pri_img_del (fdc->img[i]);
-
-		free (fdc->fname[i]);
+		if (fdc->img_del[i]) {
+			pri_img_del (fdc->img[i]);
+		}
 	}
 
 	wd179x_free (&fdc->wd179x);
···
 	fdc->diskid[drive] = diskid;
 }
 
-void rc759_fdc_set_fname (rc759_fdc_t *fdc, unsigned drive, const char *fname)
+static
+int rc759_fdc_eject_drive (rc759_fdc_t *fdc, unsigned drive)
 {
-	unsigned n;
-	char     *str;
+	wd179x_flush (&fdc->wd179x, drive);
 
-	if (drive >= 2) {
-		return;
+	if (rc759_fdc_save (fdc, drive)) {
+		return (1);
 	}
 
-	free (fdc->fname[drive]);
-	fdc->fname[drive] = NULL;
-	fdc->use_fname[drive] = 0;
+	wd179x_set_ready (&fdc->wd179x, drive, 0);
 
-	if (fname == NULL) {
-		return;
+	if (fdc->img_del[drive]) {
+		pri_img_del (fdc->img[drive]);
 	}
 
-	n = strlen (fname);
+	fdc->img[drive] = NULL;
+	fdc->img_del[drive] = 0;
 
-	str = malloc (n + 1);
-
-	if (str == NULL) {
-		return;
-	}
+	fdc->modified[drive] = 0;
 
-	memcpy (str, fname, n + 1);
-
-	fdc->fname[drive] = str;
+	return (0);
 }
 
-int rc759_fdc_insert (rc759_fdc_t *fdc, const char *str)
+static
+int rc759_fdc_insert_drive (rc759_fdc_t *fdc, unsigned drive)
 {
-	unsigned i;
-	unsigned drv;
-	char     buf[16];
+	wd179x_flush (&fdc->wd179x, drive);
 
-	i = 0;
-	while ((i < 16) && (str[i] != 0)) {
-		if (str[i] == ':') {
-			buf[i] = 0;
-			break;
-		}
-
-		buf[i] = str[i];
-
-		i += 1;
-	}
-
-	if ((i >= 16) || (i == 0) || (str[i] == 0)) {
+	if (rc759_fdc_load (fdc, drive)) {
 		return (1);
 	}
 
-	drv = strtoul (buf, NULL, 0);
-	str = str + i + 1;
+	return (0);
+}
 
-	if (rc759_fdc_save (fdc, drv)) {
-		return (1);
-	}
+int rc759_fdc_eject_disk (rc759_fdc_t *fdc, unsigned id)
+{
+	int      r;
+	unsigned i;
 
-	rc759_fdc_set_fname (fdc, drv, str);
+	r = 0;
 
-	if (rc759_fdc_load (fdc, drv)) {
-		return (1);
+	for (i = 0; i < 2; i++) {
+		if (fdc->diskid[i] == id) {
+			r |= rc759_fdc_eject_drive (fdc, i);
+		}
 	}
 
-	return (0);
+	return (r);
 }
 
-int rc759_fdc_eject (rc759_fdc_t *fdc, const char *str)
+int rc759_fdc_insert_disk (rc759_fdc_t *fdc, unsigned id)
 {
-	unsigned drv;
+	int      r;
+	unsigned i;
 
-	drv = strtoul (str, NULL, 0);
+	r = 0;
 
-	if (rc759_fdc_save (fdc, drv)) {
-		return (1);
+	for (i = 0; i < 2; i++) {
+		if (fdc->diskid[i] == id) {
+			r |= rc759_fdc_insert_drive (fdc, i);
+		}
 	}
 
-	rc759_fdc_set_fname (fdc, drv, NULL);
-
-	if (rc759_fdc_load (fdc, drv)) {
-		return (1);
-	}
-
-	return (0);
+	return (r);
 }
 
 unsigned char rc759_fdc_get_reserve (const rc759_fdc_t *fdc)
···
 }
 
 static
-pri_img_t *rc759_fdc_load_pri (rc759_fdc_t *fdc, unsigned drive)
-{
-	pri_img_t *img;
-
-	if (fdc->fname[drive] == NULL) {
-		return (NULL);
-	}
-
-	img = pri_img_load (fdc->fname[drive], PRI_FORMAT_PBIT);
-
-	return (img);
-}
-
-static
-psi_img_t *rc759_fdc_load_block (rc759_fdc_t *fdc, unsigned drive, disk_t *dsk)
+psi_img_t *rc759_fdc_load_block (rc759_fdc_t *fdc, disk_t *dsk, unsigned drive)
 {
 	unsigned      c, h, s;
 	unsigned      cn, hn, sn;
···
 }
 
 static
-pri_img_t *rc759_fdc_load_disk (rc759_fdc_t *fdc, unsigned drive)
+int rc759_fdc_load_psi (rc759_fdc_t *fdc, psi_img_t *img, unsigned drive)
 {
-	disk_t     *dsk;
-	disk_psi_t *dskpsi;
-	psi_img_t  *img, *del;
-	pri_img_t  *ret;
+	pri_enc_mfm_t par;
 
-	dsk = dsks_get_disk (fdc->dsks, fdc->diskid[drive]);
+	pri_encode_mfm_init (&par, 500000, 300);
 
-	if (dsk == NULL) {
-		return (NULL);
-	}
+	par.enable_iam = 0;
+	par.auto_gap3 = 1;
+	par.gap4a = 96;
+	par.gap1 = 0;
+	par.gap3 = 80;
 
-	if (dsk_get_type (dsk) == PCE_DISK_PSI) {
-		dskpsi = dsk->ext;
-		img = dskpsi->img;
-		del = NULL;
-	}
-	else {
-		img = rc759_fdc_load_block (fdc, drive, dsk);
-		del = img;
-	}
+	fdc->img[drive] = pri_encode_mfm (img, &par);
+	fdc->img_del[drive] = (fdc->img[drive] != NULL);
 
-	if (img == NULL) {
-		return (NULL);
-	}
+	return (0);
+}
 
-	ret = pri_encode_mfm_hd_360 (img);
+static
+int rc759_fdc_load_disk_pri (rc759_fdc_t *fdc, disk_t *dsk, unsigned drive)
+{
+	disk_pri_t *pri;
 
-	psi_img_del (del);
+	pri = dsk->ext;
 
-	return (ret);
+	fdc->img[drive] = pri->img;
+	fdc->img_del[drive] = 0;
+
+	return (0);
 }
 
-int rc759_fdc_load (rc759_fdc_t *fdc, unsigned drive)
+static
+int rc759_fdc_load_disk_psi (rc759_fdc_t *fdc, disk_t *dsk, unsigned drive)
 {
-	pri_img_t *img;
+	disk_psi_t *psi;
 
-	wd179x_flush (&fdc->wd179x, drive);
+	psi = dsk->ext;
 
-	wd179x_set_ready (&fdc->wd179x, drive, 0);
+	if (rc759_fdc_load_psi (fdc, psi->img, drive)) {
+		return (1);
+	}
 
-	img = NULL;
-
-	fdc->use_fname[drive] = 0;
+	return (0);
+}
 
-	if (fdc->fname[drive] != NULL) {
-		img = rc759_fdc_load_pri (fdc, drive);
+static
+int rc759_fdc_load_disk (rc759_fdc_t *fdc, disk_t *dsk, unsigned drive)
+{
+	int       r;
+	psi_img_t *psi;
 
-		if (img != NULL) {
-			fdc->use_fname[drive] = 1;
-			sim_log_deb ("fdc: loading drive %u (pri)\n", drive);
-		}
+	if ((psi = rc759_fdc_load_block (fdc, dsk, drive)) == NULL) {
+		return (1);
 	}
 
-	if (img == NULL) {
-		img = rc759_fdc_load_disk (fdc, drive);
+	r = rc759_fdc_load_psi (fdc, psi, drive);
+
+	psi_img_del (psi);
+
+	return (r);
+}
+
+int rc759_fdc_load (rc759_fdc_t *fdc, unsigned drive)
+{
+	unsigned type;
+	disk_t   *dsk;
 
-		if (img != NULL) {
-			sim_log_deb ("fdc: loading drive %u (disk)\n", drive);
-		}
+	if (drive >= 2) {
+		return (1);
 	}
 
-	if (img == NULL) {
-		sim_log_deb ("fdc: loading drive %u failed\n", drive);
+	rc759_fdc_eject_drive (fdc, drive);
+
+	if ((dsk = dsks_get_disk (fdc->dsks, fdc->diskid[drive])) == NULL) {
 		return (1);
 	}
 
-	pri_img_del (fdc->img[drive]);
-
-	fdc->img[drive] = img;
+	type = dsk_get_type (dsk);
 
-	fdc->modified[drive] = 0;
+	if (type == PCE_DISK_PRI) {
+		if (rc759_fdc_load_disk_pri (fdc, dsk, drive)) {
+			return (1);
+		}
+	}
+	else if (type == PCE_DISK_PSI) {
+		if (rc759_fdc_load_disk_psi (fdc, dsk, drive)) {
+			return (1);
+		}
+	}
+	else {
+		if (rc759_fdc_load_disk (fdc, dsk, drive)) {
+			return (1);
+		}
+	}
 
 	wd179x_set_ready (&fdc->wd179x, drive, 1);
 
···
 }
 
 static
-int rc759_fdc_save_block (rc759_fdc_t *fdc, unsigned drive, disk_t *dsk, psi_img_t *img)
+int rc759_fdc_save_block (rc759_fdc_t *fdc, disk_t *dsk, unsigned drive, psi_img_t *img)
 {
 	unsigned      c, h, s;
 	unsigned      cn, hn, sn;
···
 }
 
 static
-int rc759_fdc_save_disk (rc759_fdc_t *fdc, unsigned drive)
+int rc759_fdc_save_disk_pri (rc759_fdc_t *fdc, disk_t *dsk, unsigned drive)
 {
-	int        r;
-	disk_t     *dsk;
-	disk_psi_t *dskpsi;
-	psi_img_t  *img;
+	disk_pri_t *pri;
 
-	dsk = dsks_get_disk (fdc->dsks, fdc->diskid[drive]);
+	pri = dsk->ext;
+	pri->dirty = 1;
 
-	if (dsk == NULL) {
-		return (1);
-	}
+	return (0);
+}
 
-	img = pri_decode_mfm (fdc->img[drive], NULL);
+static
+int rc759_fdc_save_disk_psi (rc759_fdc_t *fdc, disk_t *dsk, unsigned drive)
+{
+	disk_psi_t *psi;
+	psi_img_t  *img;
 
-	if (img == NULL) {
+	if ((img = pri_decode_mfm (fdc->img[drive], NULL)) == NULL) {
 		return (1);
 	}
 
-	if (dsk_get_type (dsk) == PCE_DISK_PSI) {
-		dskpsi = dsk->ext;
-		psi_img_del (dskpsi->img);
-		dskpsi->img = img;
-		dskpsi->dirty = 1;
-	}
-	else {
-		r = rc759_fdc_save_block (fdc, drive, dsk, img);
-
-		psi_img_del (img);
-
-		if (r) {
-			return (1);
-		}
-	}
+	psi = dsk->ext;
+	psi_img_del (psi->img);
+	psi->img = img;
+	psi->dirty = 1;
 
 	return (0);
 }
 
 static
-int rc759_fdc_save_pri (rc759_fdc_t *fdc, unsigned drive)
+int rc759_fdc_save_disk (rc759_fdc_t *fdc, disk_t *dsk, unsigned drive)
 {
-	if (fdc->fname[drive] == NULL) {
-		return (1);
-	}
+	int       r;
+	psi_img_t *img;
 
-	if (pri_img_save (fdc->fname[drive], fdc->img[drive], PRI_FORMAT_NONE)) {
+	if ((img = pri_decode_mfm (fdc->img[drive], NULL)) == NULL) {
 		return (1);
 	}
 
-	return (0);
+	r = rc759_fdc_save_block (fdc, dsk, drive, img);
+
+	psi_img_del (img);
+
+	return (r);
 }
 
 int rc759_fdc_save (rc759_fdc_t *fdc, unsigned drive)
 {
+	unsigned type;
+	disk_t   *dsk;
+
+	if (drive >= 2) {
+		return (1);
+	}
+
 	if (fdc->img[drive] == NULL) {
 		return (1);
 	}
 
+	wd179x_flush (&fdc->wd179x, drive);
+
 	if (fdc->modified[drive] == 0) {
 		return (0);
 	}
 
-	sim_log_deb ("fdc: saving drive %u\n", drive);
+	if ((dsk = dsks_get_disk (fdc->dsks, fdc->diskid[drive])) == NULL) {
+		return (1);
+	}
 
-	if (fdc->use_fname[drive]) {
-		if (rc759_fdc_save_pri (fdc, drive)) {
-			sim_log_deb ("fdc: saving drive %u failed (pri)\n",
-				drive
-			);
+	type = dsk_get_type (dsk);
+
+	if (type == PCE_DISK_PRI) {
+		if (rc759_fdc_save_disk_pri (fdc, dsk, drive)) {
+			return (1);
+		}
+	}
+	else if (type == PCE_DISK_PSI) {
+		if (rc759_fdc_save_disk_psi (fdc, dsk, drive)) {
 			return (1);
 		}
 	}
 	else {
-		if (rc759_fdc_save_disk (fdc, drive)) {
-			sim_log_deb ("fdc: saving drive %u failed (disk)\n",
-				drive
-			);
+		if (rc759_fdc_save_disk (fdc, dsk, drive)) {
 			return (1);
 		}
 	}

src/arch/rc759/fdc.h

···
 /*****************************************************************************
  * File name:   src/arch/rc759/fdc.h                                         *
  * Created:     2012-07-05 by Hampa Hug <[e-mail]>                     *
- * Copyright:   (C) 2012-2013 Hampa Hug <[e-mail]>                     *
+ * Copyright:   (C) 2012-2019 Hampa Hug <[e-mail]>                     *
  *****************************************************************************/
 
 /*****************************************************************************
···
 
 	disks_t        *dsks;
 
-	char           use_fname[2];
-	char           *fname[2];
-
 	unsigned short diskid[2];
 
 	pri_img_t      *img[2];
+	char           img_del[2];
 
 	char           modified[2];
 } rc759_fdc_t;
···
 void rc759_fdc_set_disks (rc759_fdc_t *fdc, disks_t *dsks);
 void rc759_fdc_set_disk_id (rc759_fdc_t *fdc, unsigned drive, unsigned diskid);
 
-void rc759_fdc_set_fname (rc759_fdc_t *fdc, unsigned drive, const char *fname);
-
-int rc759_fdc_insert (rc759_fdc_t *fdc, const char *str);
+int rc759_fdc_eject_disk (rc759_fdc_t *fdc, unsigned id);
+int rc759_fdc_insert_disk (rc759_fdc_t *fdc, unsigned id);
 
 unsigned char rc759_fdc_get_reserve (const rc759_fdc_t *fdc);
 void rc759_fdc_set_reserve (rc759_fdc_t *fdc, unsigned char val);

src/arch/rc759/msg.c

···
 static
 int rc759_set_msg_disk_eject (rc759_t *sim, const char *msg, const char *val)
 {
-	unsigned drv;
-	disk_t   *dsk;
+	if (msg_dsk_get_disk_id (val, &sim->disk_id)) {
+		return (1);
+	}
 
-	while (*val != 0) {
-		if (msg_get_prefix_uint (&val, &drv, ":", " \t")) {
-			pce_log (MSG_ERR,
-				"*** disk eject error: bad drive (%s)\n",
-				val
-			);
+	rc759_fdc_eject_disk (&sim->fdc, sim->disk_id);
 
-			return (1);
-		}
-
-		pce_log (MSG_INF, "ejecting drive %lu\n", drv);
-
-		rc759_fdc_save (&sim->fdc, drv);
-		rc759_fdc_set_fname (&sim->fdc, drv, NULL);
-
-		dsk = dsks_get_disk (sim->dsks, drv);
-		dsks_rmv_disk (sim->dsks, dsk);
-		dsk_del (dsk);
-
-		rc759_fdc_load (&sim->fdc, drv);
-	}
+	msg_dsk_emu_disk_eject (val, sim->dsks, &sim->disk_id);
 
 	return (0);
 }
···
 static
 int rc759_set_msg_disk_insert (rc759_t *sim, const char *msg, const char *val)
 {
-	unsigned   i;
-	unsigned   drv;
-	const char *str, *ext;
-
-	str = val;
-
-	if (msg_get_prefix_uint (&str, &drv, ":", " \t")) {
-		pce_log (MSG_ERR,
-			"*** disk eject error: bad drive (%s)\n",
-			val
-		);
+	if (dsks_get_disk (sim->dsks, sim->disk_id) != NULL) {
+		rc759_fdc_eject_disk (&sim->fdc, sim->disk_id);
+	}
 
+	if (msg_dsk_emu_disk_insert (val, sim->dsks, sim->disk_id)) {
 		return (1);
 	}
 
-	i = 0;
-	ext = str;
-
-	while (str[i] != 0) {
-		if (str[i] == '.') {
-			ext = str + i;
-		}
-
-		i += 1;
-	}
-
-	rc759_fdc_save (&sim->fdc, drv);
-
-	if (strcasecmp (ext, ".pbit") == 0) {
-		rc759_fdc_set_fname (&sim->fdc, drv, str);
-	}
-	else {
-		if (dsk_insert (sim->dsks, val, 1)) {
-			return (1);
-		}
-	}
-
-	rc759_fdc_load (&sim->fdc, drv);
+	rc759_fdc_insert_disk (&sim->fdc, sim->disk_id);
 
 	return (0);
 }

src/arch/rc759/pce-rc759.cfg.in

···
 
 # The floppy disk controller
 fdc {
-	# The PBIT file attached to the first floppy disk drive.
-	# If this option is not set, or the file can't be read,
-	# the disk with ID 0 is used instead.
-	file0 = "fd0.pbit"
+	# The disk id used for drive 0.
+	id0 = 0
 
-	# The PBIT file attached to the second floppy disk drive.
-	# If this option is not set, or the file can't be read,
-	# the disk with ID 1 is used instead.
-	file1 = "fd1.pbit"
+	# The disk id used for drive 1.
+	id1 = 1
 }
 
 
···
 	drive    = 0
 	optional = 1
 	type     = "auto"
+	file     = "fd0.pri"
 	file     = "fd0.img"
-	file     = "fd0.pfdc"
+	file     = "fd0.psi"
 }
 
 # The second floppy drive
···
 	drive    = 1
 	optional = 1
 	type     = "auto"
+	file     = "fd1.pri"
 	file     = "fd1.img"
-	file     = "fd1.pfdc"
+	file     = "fd1.psi"
 }

src/arch/rc759/rc759.c

···
 static
 void rc759_setup_fdc (rc759_t *sim, ini_sct_t *ini)
 {
-	const char *fname0, *fname1;
-	ini_sct_t  *sct;
+	unsigned  id0, id1;
+	ini_sct_t *sct;
 
 	sct = ini_next_sct (ini, NULL, "fdc");
 
-	ini_get_string (sct, "file0", &fname0, NULL);
-	ini_get_string (sct, "file1", &fname1, NULL);
+	ini_get_uint16 (sct, "id0", &id0, 0);
+	ini_get_uint16 (sct, "id1", &id1, 1);
 
-	pce_log_tag (MSG_INF, "FDC:",
-		"file0=%s file1=%s\n",
-		(fname0 != NULL) ? fname0 : "<none>",
-		(fname1 != NULL) ? fname1 : "<none>"
-	);
+	pce_log_tag (MSG_INF, "FDC:", "drive0=%u drive1=%u\n", id0, id1);
 
 	rc759_fdc_init (&sim->fdc);
 
···
 
 	rc759_fdc_set_disks (&sim->fdc, sim->dsks);
 
-	rc759_fdc_set_fname (&sim->fdc, 0, fname0);
-	rc759_fdc_set_fname (&sim->fdc, 1, fname1);
-
-	rc759_fdc_set_disk_id (&sim->fdc, 0, 0);
-	rc759_fdc_set_disk_id (&sim->fdc, 1, 1);
+	rc759_fdc_set_disk_id (&sim->fdc, 0, id0);
+	rc759_fdc_set_disk_id (&sim->fdc, 1, id1);
 
 	rc759_fdc_load (&sim->fdc, 0);
 	rc759_fdc_load (&sim->fdc, 1);