video: Fix HDMI black screen / frozen boot on DE10-Nano clones (MiSTer-devel#1215) (MiSTer-devel#1217)

* video: bound EDID read and don't ingest garbage on DDC timeout (MiSTer-devel#1213)

* video: keep last-good EDID and skip redundant reinit on failed re-read (MiSTer-devel#1215)

* i2c: pin ADV7513 EDID/SPD/CEC to the main chip's bus to avoid a wrong-bus hang (MiSTer-devel#1215)

---------

Co-authored-by: TheJesusFish <TheJesusFish@users.noreply.github.com>

Author: pablopen

hdmi_cec.cpp

@@ -1018,7 +1018,8 @@ bool cec_init()
 
 	cec_deinit();
 
-	cec_main_fd = i2c_open(ADV7513_MAIN_ADDR, 0);
+	int adv_bus = -1;
+	cec_main_fd = i2c_open(ADV7513_MAIN_ADDR, 0, -1, &adv_bus);
 	if (cec_main_fd < 0)
 	{
 		return false;
@@ -1030,7 +1031,9 @@ bool cec_init()
 		return false;
 	}
 
-	cec_fd = i2c_open(ADV7513_CEC_ADDR, 0);
+	// CEC is a sub-map of the same chip: pin it to the main bus rather than
+	// rescanning, so a phantom on another bus can't capture the handle.
+	cec_fd = i2c_open(ADV7513_CEC_ADDR, 0, adv_bus);
 	if (cec_fd < 0)
 	{
 		cec_deinit();

smbus.cpp

@@ -209,10 +209,18 @@ int i2c_smbus_block_process_call(int file, uint8_t command, uint8_t length, uint
 	return data.block[0];
 }
 
-int i2c_open(int dev_address, int is_smbus)
+int i2c_open(int dev_address, int is_smbus, int force_bus, int *found_bus)
 {
 	char str[16];
-	for (int bus = 0; bus < 3; bus++)
+	// only /dev/i2c-0..2 exist; an out-of-range pin hint means "not found"
+	if (force_bus > 2)
+	{
+		printf("i2c_open: invalid bus %d for device 0x%X\n", force_bus, dev_address);
+		return -1;
+	}
+	int bus_first = (force_bus >= 0) ? force_bus : 0;
+	int bus_last  = (force_bus >= 0) ? force_bus : 2;
+	for (int bus = bus_first; bus <= bus_last; bus++)
 	{
 		int fd;
 		sprintf(str, "/dev/i2c-%d", bus);
@@ -250,6 +258,8 @@ int i2c_open(int dev_address, int is_smbus)
 		}
 
 		printf("Opened %s for device 0x%X\n", str, dev_address);
+		// report the matched bus so sibling chip addresses can be pinned to it
+		if (found_bus) *found_bus = bus;
 		return fd;
 	}
 

smbus.h

@@ -3,7 +3,7 @@
 #ifndef SMBUS_H
 #define SMBUS_H
 
-int i2c_open(int dev_address, int is_smbus);
+int i2c_open(int dev_address, int is_smbus, int force_bus = -1, int *found_bus = NULL);
 void i2c_close(int fd);
 
 int i2c_smbus_write_quick(int file, uint8_t value);

video.cpp

@@ -1444,23 +1444,27 @@ static void hdmi_config_init()
 
 	if (hdmi_main_fd < 0)
 	{
-		hdmi_main_fd = i2c_open(0x39, 0);
+		int adv_bus = -1;
+		hdmi_main_fd = i2c_open(0x39, 0, -1, &adv_bus);
 		if (hdmi_main_fd < 0)
 		{
 			printf("ADV7513 not found on i2c bus! HDMI won't be available!\n");
 			return;
 		}
 		else
 		{
+			// EDID/SPD are sub-maps of the same chip: pin them to the main bus
+			// instead of rescanning, or a phantom that ACKs on another bus can
+			// capture the handle and wedge the i2c controller on a real transfer.
 			if (hdmi_edid_fd < 0)
 			{
-				hdmi_edid_fd = i2c_open(0x3f, 0);
+				hdmi_edid_fd = i2c_open(0x3f, 0, adv_bus);
 				if (hdmi_edid_fd < 0) printf("ADV7513: cannot find EDID registers.\n");
 			}
 
 			if (hdmi_spd_fd < 0)
 			{
-				hdmi_spd_fd = i2c_open(0x38, 0);
+				hdmi_spd_fd = i2c_open(0x38, 0, adv_bus);
 				if (hdmi_spd_fd < 0) printf("ADV7513: cannot find SPD registers.\n");
 			}
 		}
@@ -1806,20 +1810,25 @@ static int find_edid_vrr_capability()
 
 }
 
-static int is_edid_valid()
+static int is_edid_valid_buf(const uint8_t *buf)
 {
 	static const uint8_t magic[] = { 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00 };
 	if (sizeof(edid) < sizeof(magic)) return 0;
-	return !memcmp(edid, magic, sizeof(magic));
+	return !memcmp(buf, magic, sizeof(magic));
+}
+
+static int is_edid_valid()
+{
+	return is_edid_valid_buf(edid);
 }
 
-static void cache_raw_edid_mfg_id()
+static void cache_raw_edid_mfg_id(const uint8_t *buf)
 {
-	raw_edid_mfg_id = (edid[0x08] << 8) | edid[0x09];
+	raw_edid_mfg_id = (buf[0x08] << 8) | buf[0x09];
 	raw_edid_mfg_id_valid = true;
 }
 
-static void read_edid_segment(uint8_t segment, uint8_t *buf)
+static bool read_edid_segment(uint8_t segment, uint8_t *buf)
 {
 	i2c_smbus_write_byte_data(hdmi_main_fd, 0xC4, segment);
 	i2c_smbus_write_byte_data(hdmi_main_fd, 0xC9, 0x03);
@@ -1829,28 +1838,28 @@ static void read_edid_segment(uint8_t segment, uint8_t *buf)
 	unsigned long timeout = GetTimer(500);
 	while (!CheckTimer(timeout))
 	{
-		if (i2c_smbus_read_byte_data(hdmi_main_fd, 0x96) & 4)
+		int status = i2c_smbus_read_byte_data(hdmi_main_fd, 0x96);
+		if (status >= 0 && (status & 4))
 		{
 			i2c_smbus_write_byte_data(hdmi_main_fd, 0x96, 4);
-			break;
+			for (uint16_t i = 0; i < 256; i++)
+			{
+				int value = i2c_smbus_read_byte_data(hdmi_edid_fd, (uint8_t)i);
+				buf[i] = (value < 0) ? 0 : (uint8_t)value;
+			}
+			return true;
 		}
 		usleep(10000);
 	}
 
-	for (uint16_t i = 0; i < 256; i++)
-	{
-		int value = i2c_smbus_read_byte_data(hdmi_edid_fd, (uint8_t)i);
-		buf[i] = (value < 0) ? 0 : (uint8_t)value;
-	}
+	return false;
 }
 
 static int read_edid(bool force = false)
 {
 	if (hdmi_main_fd < 0 || hdmi_edid_fd < 0) return 0;
 	if (is_edid_valid() && !force) return 1;
 
-	memset(edid, 0, sizeof(edid));
-
 	//Test if adv7513 senses hdmi clock. If not, don't bother with the edid query
 	int hpd_state = i2c_smbus_read_byte_data(hdmi_main_fd, 0x42);
 	if (hpd_state < 0 || !(hpd_state & 0x20))
@@ -1859,35 +1868,57 @@ static int read_edid(bool force = false)
 		return 0;
 	}
 
+	// read into scratch; replace live edid[] only on a valid read, so a transient failure can't blank it
+	uint8_t buf[sizeof(edid)] = {};
+	bool ddc_responded = false;
+
 	// waiting for valid EDID
 	for (int k = 0; k < 20; k++)
 	{
-		read_edid_segment(0, edid);
-		if (is_edid_valid()) break;
+		int current = i2c_smbus_read_byte_data(hdmi_main_fd, 0x42);
+		if (current < 0 || !(current & 0x20))
+		{
+			raw_edid_mfg_id_valid = false;
+			return 0;
+		}
+		bool got_interrupt = read_edid_segment(0, buf);
+		if (got_interrupt) ddc_responded = true;
+		if (is_edid_valid_buf(buf)) break;
+		if (!got_interrupt) break;  // no DDC response — display has no EDID, don't retry
 		usleep(100000);
 	}
 
-	if (is_edid_valid())
+	if (!is_edid_valid_buf(buf))
 	{
-		uint8_t max_blocks = sizeof(edid) / 256;
-		uint8_t blocks = (2 + edid[126]) / 2; // each block is 128 bytes
-		if (blocks > max_blocks) blocks = max_blocks;
-		for (uint8_t i = 1; i < blocks; i++) read_edid_segment(i, edid + (i * 256));
+		if (ddc_responded)
+		{
+			// header bad but DDC answered: still cache raw mfg id for non-conformant DAC EDIDs
+			cache_raw_edid_mfg_id(buf);
+			printf("Invalid EDID: incorrect header.\n");
+		}
+		else
+		{
+			printf("Invalid EDID: no DDC response.\n");
+		}
+		// stored edid[], not buf: only when a prior valid read is being kept
+		if (is_edid_valid()) printf("Invalid EDID: keeping last valid EDID.\n");
+
+		return 0;
 	}
 
+	uint8_t max_blocks = sizeof(edid) / 256;
+	uint8_t blocks = (2 + buf[126]) / 2; // each block is 128 bytes
+	if (blocks > max_blocks) blocks = max_blocks;
+	for (uint8_t i = 1; i < blocks; i++) read_edid_segment(i, buf + (i * 256));
+
+	memcpy(edid, buf, sizeof(edid));
+
 	printf("EDID:\n");
 	uint8_t n = edid[126] + 1;
 	if (n > sizeof(edid) / 128) n = sizeof(edid) / 128;
 	hexdump(edid, n*128, 0);
 
-	cache_raw_edid_mfg_id();
-
-	if (!is_edid_valid())
-	{
-		printf("Invalid EDID: incorrect header.\n");
-		bzero(edid, sizeof(edid));
-		return 0;
-	}
+	cache_raw_edid_mfg_id(edid);
 
 	edid_version++;
 	return 1;
@@ -2686,10 +2717,20 @@ void video_init()
 
 void video_reinit()
 {
+	int prev_ver = edid_version;
+	read_edid(true);
+
+	// re-read gave nothing new but a valid EDID is still held: the mode is unchanged,
+	// so don't bounce a working link (some clones can't re-lock mid-operation)
+	if (edid_version == prev_ver && is_edid_valid())
+	{
+		printf("*** Video re-init skipped: EDID unchanged.\n");
+		return;
+	}
+
 	printf("*** Video re-initialization.\n");
 
 	hdmi_config_init();
-	read_edid(true);
 	hdmi_config_set_hdr();
 
 	support_FHD = 0;