mac: Add emulated DaynaPORT SCSI/Link-3 ethernet device

Currently only works on OpenBSD and requires read/write access to
the tap device (/dev/tap0 by default). A helper script is run after
bringing up the device to do things as root like assign an IP (for
NAT) or configure bridging (for ethernet).

SCSI protocol information was gleaned from the DaynaPORT driver in
RASCSI and my real DaynaPORT device.

src/arch/macplus/Makefile.inc

···
 	msg \
 	rtc \
 	scsi \
+	scsi_tap \
 	serial \
 	sony \
 	sound \
···
 $(rel)/msg.o:		$(rel)/msg.c
 $(rel)/rtc.o:		$(rel)/rtc.c
 $(rel)/scsi.o:		$(rel)/scsi.c
+$(rel)/scsi_tap.o:	$(rel)/scsi_tap.c
 $(rel)/serial.o:	$(rel)/serial.c
 $(rel)/sony.o:		$(rel)/sony.c
 $(rel)/sound.o:		$(rel)/sound.c

src/arch/macplus/macplus.c

···
 	ini_sct_t     *sct, *sctdev;
 	mem_blk_t     *blk;
 	unsigned long addr, size;
-	unsigned      id, drive;
-	const char    *vendor, *product;
+	unsigned      id, drive, ethernet;
+	const char    *vendor, *product, *mac_addr, *tap_dev, *tap_cmd;
 
 	sct = ini_next_sct (ini, NULL, "scsi");
 
···
 	while (sctdev != NULL) {
 		ini_get_uint16 (sctdev, "id", &id, 0);
 		ini_get_uint16 (sctdev, "drive", &drive, 0);
-		ini_get_string (sctdev, "vendor", &vendor, "PCE");
-		ini_get_string (sctdev, "product", &product, "PCEDISK");
+		ini_get_uint16 (sctdev, "ethernet", &ethernet, 0);
 
-		pce_log_tag (MSG_INF,
-			"SCSI:", "id=%u drive=%u vendor=\"%s\" product=\"%s\"\n",
-			id, drive, vendor, product
-		);
+		if (drive) {
+			ini_get_string (sctdev, "vendor", &vendor, "PCE");
+			ini_get_string (sctdev, "product", &product, "PCEDISK");
 
-		mac_scsi_set_drive (&sim->scsi, id, drive);
-		mac_scsi_set_drive_vendor (&sim->scsi, id, vendor);
-		mac_scsi_set_drive_product (&sim->scsi, id, product);
+			pce_log_tag (MSG_INF,
+				"SCSI:",
+				"id=%u drive=%u vendor=\"%s\" product=\"%s\"\n",
+				id, drive, vendor, product
+			);
+
+			mac_scsi_set_drive (&sim->scsi, id, drive);
+			mac_scsi_set_drive_vendor (&sim->scsi, id, vendor);
+			mac_scsi_set_drive_product (&sim->scsi, id, product);
+		}
+		else if (ethernet) {
+			ini_get_string (sctdev, "tap", &tap_dev, "/dev/tap0");
+			ini_get_string (sctdev, "tap_cmd", &tap_cmd, "");
+			ini_get_string (sctdev, "mac_addr", &mac_addr, "00:80:19:c0:ff:ee");
+
+			pce_log_tag (MSG_INF,
+				"SCSI:",
+				"id=%u ethernet=%u tap=%s cmd=%s mac_addr=%s\n",
+				id, ethernet, tap_dev, tap_cmd, mac_addr
+			);
+
+			mac_scsi_set_ethernet (&sim->scsi, id, tap_dev, tap_cmd, mac_addr);
+		}
 
 		sctdev = ini_next_sct (sct, sctdev, "device");
 	}

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

···
 		id    = 2
 		drive = 130
 	}
+
+	# DaynaPORT SCSI/Link device emulation on SCSI id 3.
+	# Requires read/write access on the "tap" device listed here.
+	#device {
+	#	id       = 3
+	#	ethernet = 1
+	#	tap      = "/dev/tap0"    # OpenBSD
+	#	tap      = "/dev/net/tun" # Linux
+	#	mac_addr = "00:80:19:c0:ff:ee"
+	#
+	#	# This command will be run after initializing the tap device
+	#	# and will have the tap device and MAC address passed as
+	#	# arguments.  It should probably assign an IP to this tap
+	#	# device if using NAT (required on WiFi), or setup bridging
+	#	# if using ethernet.
+	#	tap_cmd  = "sh /etc/pce/tap-setup.sh"
+	#}
 }
 
 

src/arch/macplus/scsi.c

···
 
 #include <drivers/block/block.h>
 
+#include <lib/log.h>
+
 
 /* ICR 1 */
 #define E5380_ICR_RST  0x80
···
 
 	scsi->dev[id].valid = 1;
 	scsi->dev[id].drive = drive;
+	scsi->dev[id].type = MAC_SCSI_DEV_DISK;
 
 	memcpy (scsi->dev[id].vendor, "PCE     ", 8);
 	memcpy (scsi->dev[id].product, "PCEDISK         ", 16);
···
 		else {
 			dst[i] = *(product++);
 		}
+	}
+}
+
+void mac_scsi_set_ethernet (mac_scsi_t *scsi, unsigned id, const char *tap_dev, const char *tap_cmd, const char *mac_addr)
+{
+	int mac_addr_ints[6];
+	int ret;
+
+	id &= 7;
+
+	scsi->dev[id].valid = 0;
+	scsi->dev[id].type = MAC_SCSI_DEV_ETHERNET;
+
+	memcpy (scsi->dev[id].vendor, "Dayna   ", 8);
+	memcpy (scsi->dev[id].product, "SCSI/Link       ", 16);
+	memcpy (scsi->dev[id].revision, "2.0f", 4);
+
+	strlcpy (scsi->dev[id].tap_dev, tap_dev, sizeof(scsi->dev[id].tap_dev));
+	strlcpy (scsi->dev[id].tap_cmd, tap_cmd, sizeof(scsi->dev[id].tap_cmd));
+
+	ret = sscanf(mac_addr, "%x:%x:%x:%x:%x:%x",
+		&mac_addr_ints[0], &mac_addr_ints[1],
+		&mac_addr_ints[2], &mac_addr_ints[3],
+		&mac_addr_ints[4], &mac_addr_ints[5]);
+	if (ret == 6) {
+		for (int i = 0; i <= 5; i++)
+			scsi->dev[id].mac_addr[i] = mac_addr_ints[i] & 0xff;
+	} else {
+		pce_log (MSG_ERR, "*** invalid MAC address (%s)\n", mac_addr);
+	}
+
+	if (mac_scsi_ethernet_tap_open (scsi, &scsi->dev[id]) == 0) {
+		scsi->dev[id].valid = 1;
 	}
 }
 
···
 static
 void mac_scsi_cmd_read (mac_scsi_t *scsi, unsigned long lba, unsigned long cnt)
 {
-	disk_t *dsk;
+	mac_scsi_dev_t *dev;
+	disk_t         *dsk;
+	int            psize;
 
-	dsk = mac_scsi_get_disk (scsi);
+	dev = mac_scsi_get_device (scsi);
 
-	if (dsk == NULL) {
+	if (dev == NULL) {
 		mac_scsi_set_phase_status (scsi, 0x02);
 		return;
 	}
 
+	switch (dev->type) {
+	case MAC_SCSI_DEV_DISK:
+		dsk = mac_scsi_get_disk (scsi);
+
+		if (dsk == NULL) {
+			mac_scsi_set_phase_status (scsi, 0x02);
+			return;
+		}
+
 #ifdef DEBUG_SCSI
-	mac_log_deb ("scsi: read %u blocks at %lu\n", cnt, lba);
+		mac_log_deb ("scsi: read %u blocks at %lu\n", cnt, lba);
 #endif
 
-	if (mac_scsi_set_buf_max (scsi, 512UL * cnt)) {
-		mac_log_deb ("scsi: too many blocks (%u)\n", cnt);
-		mac_scsi_set_phase_status (scsi, 0x02);
-		return;
-	}
+		if (mac_scsi_set_buf_max (scsi, 512UL * cnt)) {
+			mac_log_deb ("scsi: too many blocks (%u)\n", cnt);
+			mac_scsi_set_phase_status (scsi, 0x02);
+			return;
+		}
+
+		if (dsk_read_lba (dsk, scsi->buf, lba, cnt)) {
+			mac_log_deb ("scsi: read error at %lu + %lu\n", lba, cnt);
+			mac_scsi_set_phase_status (scsi, 0x02);
+			return;
+		}
 
-	if (dsk_read_lba (dsk, scsi->buf, lba, cnt)) {
-		mac_log_deb ("scsi: read error at %lu + %lu\n", lba, cnt);
-		mac_scsi_set_phase_status (scsi, 0x02);
-		return;
-	}
+		scsi->buf_i = 0;
+		scsi->buf_n = 512 * cnt;
 
-	scsi->buf_i = 0;
-	scsi->buf_n = 512 * cnt;
+		mac_scsi_set_phase_data_in (scsi);
+		break;
+	case MAC_SCSI_DEV_ETHERNET:
+		if (cnt == 1) {
+			mac_scsi_set_phase_status (scsi, 0x02);
+			return;
+		}
 
-	mac_scsi_set_phase_data_in (scsi);
+		cnt = 1514 + 6;
+
+		if (mac_scsi_set_buf_max (scsi, cnt)) {
+			mac_scsi_set_phase_status (scsi, 0x02);
+			return;
+		}
+
+		memset (scsi->buf, 0, cnt);
+
+		psize = mac_scsi_ethernet_read (dev, scsi->buf + 6);
+		if (psize > 0) {
+			scsi->buf[0] = (psize >> 8) & 0xff;
+			scsi->buf[1] = psize & 0xff;
+
+			if (mac_scsi_ethernet_data_avail (dev)) {
+				scsi->buf[5] = 0x10;
+			}
+		}
+
+		scsi->buf_i = 0;
+		scsi->buf_n = psize + 6;
+
+		mac_scsi_set_phase_data_in (scsi);
+		break;
+	}
 }
 
 static
···
 static
 void mac_scsi_cmd_write_finish (mac_scsi_t *scsi, unsigned long lba, unsigned long cnt)
 {
-	disk_t *dsk;
+	mac_scsi_dev_t *dev;
+	disk_t         *dsk;
 
-	dsk = mac_scsi_get_disk (scsi);
+	dev = mac_scsi_get_device (scsi);
 
-	if (dsk == NULL) {
+	if (dev == NULL) {
 		mac_scsi_set_phase_status (scsi, 0x02);
 		return;
 	}
 
-	if ((512 * cnt) != scsi->buf_i) {
-		mac_log_deb ("scsi: write size mismatch (%u / %u)\n",
-			512 * cnt, scsi->buf_i
-		);
-		mac_scsi_set_phase_status (scsi, 0x02);
-		return;
-	}
+	switch (dev->type) {
+	case MAC_SCSI_DEV_DISK:
+		dsk = mac_scsi_get_disk (scsi);
+
+		if (dsk == NULL) {
+			mac_scsi_set_phase_status (scsi, 0x02);
+			return;
+		}
+
+		if ((512 * cnt) != scsi->buf_i) {
+			mac_log_deb ("scsi: write size mismatch (%u / %u)\n",
+				512 * cnt, scsi->buf_i
+			);
+			mac_scsi_set_phase_status (scsi, 0x02);
+			return;
+		}
 
 #ifdef DEBUG_SCSI
-	mac_log_deb ("scsi: write %u blocks at %lu\n", cnt, lba);
+		mac_log_deb ("scsi: write %u blocks at %lu\n", cnt, lba);
 #endif
 
-	if (dsk_write_lba (dsk, scsi->buf, lba, cnt)) {
-		mac_log_deb ("scsi: write error\n");
-		mac_scsi_set_phase_status (scsi, 0x02);
-		return;
+		if (dsk_write_lba (dsk, scsi->buf, lba, cnt)) {
+			mac_log_deb ("scsi: write error\n");
+			mac_scsi_set_phase_status (scsi, 0x02);
+			return;
+		}
+		break;
+	case MAC_SCSI_DEV_ETHERNET:
+		if (scsi->cmd[5] == 0x80) {
+			mac_scsi_ethernet_write (dev, scsi->buf + 4, cnt);
+		} else {
+			mac_scsi_ethernet_write (dev, scsi->buf, cnt);
+		}
+		break;
 	}
 
 	scsi->buf_i = 0;
···
 static
 void mac_scsi_cmd_write6 (mac_scsi_t *scsi)
 {
-	unsigned cnt;
+	mac_scsi_dev_t *dev;
+	unsigned long  size;
+	unsigned       cnt;
+
+	dev = mac_scsi_get_device (scsi);
+
+	if (dev == NULL) {
+		mac_scsi_set_phase_status (scsi, 0x02);
+		return;
+	}
 
 	cnt = scsi->cmd[4];
 
···
 		cnt = 256;
 	}
 
-	if (mac_scsi_set_buf_max (scsi, 512UL * cnt)) {
+	switch (dev->type) {
+	case MAC_SCSI_DEV_DISK:
+		size = 512UL * cnt;
+		break;
+
+	case MAC_SCSI_DEV_ETHERNET:
+		size = scsi->cmd[4] + (scsi->cmd[3] << 8);
+		if (scsi->cmd[5] == 0x80) {
+			size += 8;
+		}
+		break;
+	}
+
+	if (mac_scsi_set_buf_max (scsi, size)) {
 		mac_log_deb ("scsi: write block count %u\n", cnt);
 		mac_scsi_set_phase_status (scsi, 0x02);
 		return;
 	}
 
 	scsi->buf_i = 0;
-	scsi->buf_n = 512 * cnt;
+	scsi->buf_n = size;
 
 	scsi->cmd_finish = mac_scsi_cmd_write6_finish;
 
···
 static
 void mac_scsi_cmd_verify10 (mac_scsi_t *scsi)
 {
-	unsigned long lba;
-	unsigned      cnt;
-	disk_t        *dsk;
+	mac_scsi_dev_t *dev;
+	unsigned long  lba;
+	unsigned       cnt;
+	disk_t         *dsk;
 
-	dsk = mac_scsi_get_disk (scsi);
+	dev = mac_scsi_get_device (scsi);
 
-	if (dsk == NULL) {
+	if (dev == NULL) {
 		mac_scsi_set_phase_status (scsi, 0x02);
 		return;
 	}
 
-	/* lun = (scsi->cmd[1] >> 5) & 0x07; */
+	switch (dev->type) {
+	case MAC_SCSI_DEV_DISK:
+		dsk = mac_scsi_get_disk (scsi);
+
+		if (dsk == NULL) {
+			mac_scsi_set_phase_status (scsi, 0x02);
+			return;
+		}
+
+		/* lun = (scsi->cmd[1] >> 5) & 0x07; */
 
-	lba = scsi->cmd[2];
-	lba = (lba << 8) | scsi->cmd[3];
-	lba = (lba << 8) | scsi->cmd[4];
-	lba = (lba << 8) | scsi->cmd[5];
+		lba = scsi->cmd[2];
+		lba = (lba << 8) | scsi->cmd[3];
+		lba = (lba << 8) | scsi->cmd[4];
+		lba = (lba << 8) | scsi->cmd[5];
 
-	cnt = scsi->cmd[7];
-	cnt = (cnt << 8) | scsi->cmd[8];
+		cnt = scsi->cmd[7];
+		cnt = (cnt << 8) | scsi->cmd[8];
 
 #ifdef DEBUG_SCSI
-	mac_log_deb ("scsi: verify %u blocks at %lu\n", cnt, lba);
+		mac_log_deb ("scsi: verify %u blocks at %lu\n", cnt, lba);
 #endif
+		break;
+	case MAC_SCSI_DEV_ETHERNET:
+		break;
+	}
 
 	scsi->buf_i = 0;
 	scsi->buf_n = 0;
···
 	if (dev != NULL) {
 		memcpy (scsi->buf + 8, dev->vendor, 8);
 		memcpy (scsi->buf + 16, dev->product, 16);
+		memcpy (scsi->buf + 32, dev->revision, 4);
+
+		switch (dev->type) {
+		case MAC_SCSI_DEV_DISK:
+			scsi->buf[0] = 0x00; /* direct-access device */
+			break;
+
+		case MAC_SCSI_DEV_ETHERNET:
+			scsi->buf[0] = 0x03; /* processor device */
+			scsi->buf[2] = 0x01;
+			break;
+		}
 	}
 
 	scsi->buf[4] = 32;
···
 static
 void mac_scsi_cmd_mode_sense (mac_scsi_t *scsi)
 {
-	disk_t *dsk;
+	mac_scsi_dev_t *dev;
+	disk_t         *dsk;
 
-	dsk = mac_scsi_get_disk (scsi);
+	dev = mac_scsi_get_device (scsi);
 
-	if (dsk == NULL) {
+	if (dev == NULL) {
 		mac_scsi_set_phase_status (scsi, 0x02);
 		return;
 	}
 
-	memset (scsi->buf, 0, 512);
+	switch (dev->type) {
+	case MAC_SCSI_DEV_DISK:
+		dsk = mac_scsi_get_disk (scsi);
 
-	scsi->buf_i = 0;
-	scsi->buf_n = 0;
+		if (dsk == NULL) {
+			mac_scsi_set_phase_status (scsi, 0x02);
+			return;
+		}
 
-	switch (scsi->cmd[2] & 0x3f) {
-	case 0x01: /* read-write error recovery page */
-		scsi->buf[0] = 0x01;
-		scsi->buf[1] = 10;
-		scsi->buf_n = 12;
-		break;
+		memset (scsi->buf, 0, 512);
+
+		scsi->buf_i = 0;
+		scsi->buf_n = 0;
+
+		switch (scsi->cmd[2] & 0x3f) {
+		case 0x01: /* read-write error recovery page */
+			scsi->buf[0] = 0x01;
+			scsi->buf[1] = 10;
+			scsi->buf_n = 12;
+			break;
+
+		case 0x03: /* format device page */
+			scsi->buf[0] = 0x03;
+			scsi->buf[1] = 22;
+			scsi->buf_n = 24;
+			break;
 
-	case 0x03: /* format device page */
-		scsi->buf[0] = 0x03;
-		scsi->buf[1] = 22;
-		scsi->buf_n = 24;
-		break;
+		case 0x04: /* rigid disk drive geometry page */
+			scsi->buf[0] = 0x04;
+			scsi->buf[1] = 22;
+			scsi->buf[2] = 0;
+			buf_set_uint16_be (scsi->buf, 3, dsk->c);
+			scsi->buf[5] = dsk->h;
+			buf_set_uint16_be (scsi->buf, 20, 3600);
+			scsi->buf_n = 32;
+			break;
 
-	case 0x04: /* rigid disk drive geometry page */
-		scsi->buf[0] = 0x04;
-		scsi->buf[1] = 22;
-		scsi->buf[2] = 0;
-		buf_set_uint16_be (scsi->buf, 3, dsk->c);
-		scsi->buf[5] = dsk->h;
-		buf_set_uint16_be (scsi->buf, 20, 3600);
-		scsi->buf_n = 32;
-		break;
+		case 0x30: /* vendor specific */
+			scsi->buf[0] = 0x30;
+			scsi->buf[1] = 33;
+			strcpy ((char *) scsi->buf + 14, "APPLE COMPUTER, INC");
+			scsi->buf_n = 34;
+			break;
 
-	case 0x30: /* vendor specific */
-		scsi->buf[0] = 0x30;
-		scsi->buf[1] = 33;
-		strcpy ((char *) scsi->buf + 14, "APPLE COMPUTER, INC");
-		scsi->buf_n = 34;
+		default:
+			mac_log_deb ("scsi: mode sense: unknown mode page (%02X)\n",
+				scsi->cmd[2]
+			);
+			break;
+		}
 		break;
 
-	default:
-		mac_log_deb ("scsi: mode sense: unknown mode page (%02X)\n",
-			scsi->cmd[2]
-		);
+	case MAC_SCSI_DEV_ETHERNET:
 		break;
 	}
 
···
 static
 void mac_scsi_cmd_read_capacity (mac_scsi_t *scsi)
 {
-	unsigned long cnt;
-	disk_t        *dsk;
+	unsigned long  cnt;
+	mac_scsi_dev_t *dev;
+	disk_t         *dsk;
 
-	dsk = mac_scsi_get_disk (scsi);
+	dev = mac_scsi_get_device (scsi);
 
-	if (dsk == NULL) {
+	if (dev == NULL) {
 		mac_scsi_set_phase_status (scsi, 0x02);
 		return;
 	}
 
-	cnt = dsk_get_block_cnt (dsk);
-	buf_set_uint32_be (scsi->buf, 0, cnt - 1);
-	buf_set_uint32_be (scsi->buf, 4, 512);
+	switch (dev->type) {
+	case MAC_SCSI_DEV_DISK:
+		dsk = mac_scsi_get_disk (scsi);
+
+		if (dsk == NULL) {
+			mac_scsi_set_phase_status (scsi, 0x02);
+			return;
+		}
+
+		cnt = dsk_get_block_cnt (dsk);
+		buf_set_uint32_be (scsi->buf, 0, cnt - 1);
+		buf_set_uint32_be (scsi->buf, 4, 512);
+		break;
+
+	case MAC_SCSI_DEV_ETHERNET:
+		buf_set_uint32_be (scsi->buf, 0, 1);
+		buf_set_uint32_be (scsi->buf, 4, 512);
+		break;
+	}
 
 	scsi->buf_i = 0;
 	scsi->buf_n = 8;
···
 }
 
 
+/* DaynaPort vendor commands */
+
+static
+void mac_scsi_cmd_read_stats (mac_scsi_t *scsi)
+{
+	mac_scsi_dev_t *dev;
+
+	dev = mac_scsi_get_device (scsi);
+
+	if (dev == NULL || dev->type != MAC_SCSI_DEV_ETHERNET) {
+		mac_scsi_set_phase_status (scsi, 0x02);
+		return;
+	}
+
+	memset (scsi->buf, 0, 18);
+
+	memcpy(scsi->buf, dev->mac_addr, 6);
+	/* three 32-bit counters expected to follow, just return zero for all */
+
+	scsi->buf_i = 0;
+	scsi->buf_n = 18;
+
+	mac_scsi_set_phase_data_in (scsi);
+}
+
+static
+void mac_scsi_cmd_set_interface_mode (mac_scsi_t *scsi)
+{
+	mac_scsi_dev_t *dev;
+	unsigned char  cmd;
+
+	dev = mac_scsi_get_device (scsi);
+
+	if (dev == NULL || dev->type != MAC_SCSI_DEV_ETHERNET) {
+		mac_scsi_set_phase_status (scsi, 0x02);
+		return;
+	}
+
+	cmd = scsi->cmd[5] & 0x80;
+
+	switch (cmd) {
+	case 0x40:
+		/* set MAC */
+		break;
+
+	case 0x80:
+		/* set mode */
+		break;
+
+	default:
+		mac_log_deb ("scsi: unknown interface mode command (%02X)\n", cmd);
+	}
+
+	mac_scsi_set_phase_status (scsi, 0x02);
+}
+
+static
+void mac_scsi_cmd_set_mcast_addr (mac_scsi_t *scsi)
+{
+	mac_scsi_dev_t *dev;
+
+	dev = mac_scsi_get_device (scsi);
+
+	if (dev == NULL || dev->type != MAC_SCSI_DEV_ETHERNET) {
+		mac_scsi_set_phase_status (scsi, 0x02);
+		return;
+	}
+
+	mac_scsi_set_phase_status (scsi, 0x02);
+}
+
+static
+void mac_scsi_cmd_enable_interface (mac_scsi_t *scsi)
+{
+	mac_scsi_dev_t *dev;
+
+	dev = mac_scsi_get_device (scsi);
+
+	if (dev == NULL || dev->type != MAC_SCSI_DEV_ETHERNET) {
+		mac_scsi_set_phase_status (scsi, 0x02);
+		return;
+	}
+
+	dev->tap_enabled = !!(scsi->cmd[5] & 0x80);
+
+	mac_scsi_set_phase_status (scsi, 0x02);
+}
+
+
 static
 void mac_scsi_set_cmd (mac_scsi_t *scsi, unsigned cnt, void (*cmd) (mac_scsi_t *scsi))
 {
···
 		mac_scsi_set_cmd (scsi, 6, mac_scsi_cmd_read6);
 		break;
 
+	case 0x09:
+		mac_scsi_set_cmd (scsi, 6, mac_scsi_cmd_read_stats);
+		break;
+
 	case 0x0a:
 		mac_scsi_set_cmd (scsi, 6, mac_scsi_cmd_write6);
+		break;
+
+	case 0x0c:
+		mac_scsi_set_cmd (scsi, 6, mac_scsi_cmd_set_interface_mode);
+		break;
+
+	case 0x0d:
+		mac_scsi_set_cmd (scsi, 6, mac_scsi_cmd_set_mcast_addr);
+		break;
+
+	case 0x0e:
+		mac_scsi_set_cmd (scsi, 6, mac_scsi_cmd_enable_interface);
 		break;
 
 	case 0x12:
···
 
 			scsi->icr &= ~E5380_ICR_BSY;
 
-			if (mac_scsi_get_disk (scsi) != NULL) {
+			if (mac_scsi_get_device (scsi) != NULL) {
 				mac_scsi_set_phase_cmd (scsi);
 				mac_scsi_set_int (scsi, 1);
 			}

src/arch/macplus/scsi.h

···
 #define PCE_MACPLUS_SCSI_H 1
 
 
+#include <limits.h>
+
 #include <drivers/block/block.h>
 
+enum {
+	MAC_SCSI_DEV_UNKNOWN,
+	MAC_SCSI_DEV_DISK,
+	MAC_SCSI_DEV_ETHERNET,
+};
 
 typedef struct {
 	int           valid;
 
+	int           type;
+
 	/* the PCE drive number */
 	unsigned      drive;
 
 	unsigned char vendor[8];
 	unsigned char product[16];
+	unsigned char revision[4];
+
+	int           tap_enabled;
+	unsigned char mac_addr[6];
+	char          tap_dev[PATH_MAX];
+	char          tap_cmd[PATH_MAX];
+	int           tap_fd;
 } mac_scsi_dev_t;
 
 
···
 void mac_scsi_set_drive (mac_scsi_t *scsi, unsigned id, unsigned drive);
 void mac_scsi_set_drive_vendor (mac_scsi_t *scsi, unsigned id, const char *vendor);
 void mac_scsi_set_drive_product (mac_scsi_t *scsi, unsigned id, const char *product);
+void mac_scsi_set_ethernet (mac_scsi_t *scsi, unsigned id, const char *tap_dev, const char *tap_cmd, const char *mac_addr);
 
 unsigned char mac_scsi_get_uint8 (void *ext, unsigned long addr);
 unsigned short mac_scsi_get_uint16 (void *ext, unsigned long addr);
···
 
 void mac_scsi_reset (mac_scsi_t *scsi);
 
+int mac_scsi_ethernet_tap_open (mac_scsi_t *scsi, mac_scsi_dev_t *dev);
+int mac_scsi_ethernet_data_avail (mac_scsi_dev_t *dev);
+size_t mac_scsi_ethernet_read (mac_scsi_dev_t *dev, unsigned char *buf);
+size_t mac_scsi_ethernet_write (mac_scsi_dev_t *dev, unsigned char *buf, size_t len);
 
 #endif

src/arch/macplus/scsi_tap.c

···
+/*****************************************************************************
+ * pce                                                                       *
+ *****************************************************************************/
+
+/*****************************************************************************
+ * File name:   src/arch/macplus/scsi_tap.c                                  *
+ * Created:     2022-05-01 by joshua stein <[e-mail]>                     *
+ * Copyright:   (C) 2022 joshua stein <[e-mail]>                          *
+ *****************************************************************************/
+
+/*****************************************************************************
+ * This program is free software. You can redistribute it and / or modify it *
+ * under the terms of the GNU General Public License version 2 as  published *
+ * by the Free Software Foundation.                                          *
+ *                                                                           *
+ * This program is distributed in the hope  that  it  will  be  useful,  but *
+ * WITHOUT  ANY   WARRANTY,   without   even   the   implied   warranty   of *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU  General *
+ * Public License for more details.                                          *
+ *****************************************************************************/
+
+#include "main.h"
+#include "scsi.h"
+
+#include <stdlib.h>
+
+#include <lib/log.h>
+
+#include <errno.h>
+#include <string.h>
+#include <poll.h>
+#include <sys/fcntl.h>
+#include <sys/types.h>
+int mac_scsi_ethernet_tap_open (mac_scsi_t *scsi, mac_scsi_dev_t *dev)
+{
+	char tap_cmd_sh[1024];
+
+	dev->tap_fd = -1;
+
+	if ((dev->tap_fd = open (dev->tap_dev, O_RDWR)) < 0) {
+		pce_log (MSG_ERR, "*** opening %s failed (%s)\n", dev->tap_dev, strerror(errno));
+		return - 1;
+	}
+
+	if (dev->tap_cmd[0] != '\0') {
+		/* run command with args "/dev/tap0" "00:00:00:00:00:00" */
+		snprintf (tap_cmd_sh, sizeof(tap_cmd_sh), "%s \"%s\" \"%02x:%02x:%02x:%02x:%02x:%02x\"",
+			dev->tap_cmd, dev->tap_dev,
+			dev->mac_addr[0], dev->mac_addr[1],
+			dev->mac_addr[2], dev->mac_addr[3],
+			dev->mac_addr[4], dev->mac_addr[5]);
+		pce_log_tag (MSG_INF,
+			"SCSI:",
+			"running tap command: %s\n",
+			tap_cmd_sh);
+
+		if (system (tap_cmd_sh) != 0) {
+			pce_log (MSG_ERR, "*** tap command failed (%s)\n", strerror(errno));
+		}
+	}
+
+	return 0;
+}
+
+int mac_scsi_ethernet_data_avail (mac_scsi_dev_t *dev)
+{
+	struct pollfd fds;
+
+	fds.fd = dev->tap_fd;
+	fds.events = POLLIN | POLLERR;
+	if (poll (&fds, 1, 0) < 1) {
+		return 0;
+	}
+	if ((fds.revents & POLLIN)) {
+		return 1;
+	}
+
+	return 0;
+}
+
+size_t mac_scsi_ethernet_read (mac_scsi_dev_t *dev, unsigned char *buf)
+{
+	if (dev->tap_fd < 0) {
+		return 0;
+	}
+
+	if (!mac_scsi_ethernet_data_avail (dev)) {
+		return 0;
+	}
+
+	return read (dev->tap_fd, buf, 1514);
+}
+
+size_t mac_scsi_ethernet_write (mac_scsi_dev_t *dev, unsigned char *buf, size_t len)
+{
+	if (dev->tap_fd < 0) {
+		return 0;
+	}
+
+	return write (dev->tap_fd, buf, len);
+}