d4xx: add post-reset HWMC readiness gate and fix GVD retry logic

RSDSO-21151

After HW reset, the driver returned success to userspace ~54ms before
the firmware's HWMC subsystem was ready for commands.  RS Viewer
immediately queried GVD/HWMC, hitting I2C EREMOTEIO (-121) failures
and WIP/ERR status codes for seconds, eventually crashing.

Root causes and fixes:

1) ds5_hw_reset_with_recovery: Add Step 9 HWMC readiness check.
   After device type is confirmed (Step 8), send a lightweight GVD
   command and poll HWMC_STATUS until completion before returning
   to userspace.  This blocks the caller until the FW command
   processor is fully operational, preventing the race window.

2) ds5_gvd: Fix retry loop condition.  The old condition
   'ret && retries-- && status != 0' only retried on I2C failure.
   If I2C succeeded but status was WIP (2), ret==0 caused immediate
   loop exit.  Changed to '(ret || status == WIP) && retries--'
   to retry on both I2C errors and WIP.  Increased retries from
   3x10ms to 20x50ms for transient post-reset conditions.

3) ds5_gvd: Fix return value.  Previously returned raw HWMC status
   (positive int, e.g. 2 for WIP) on failure.  V4L2 g_volatile_ctrl
   interprets positive returns as success, so userspace received
   garbage GVD data.  Now returns -EIO on failure.

4) ds5_get_hwmc_status: Add I2C retry tolerance.  The loop exited
   immediately on I2C failure (!ret was false).  Changed condition
   to continue retrying on both I2C failures and WIP status, with
   a dev_dbg trace for I2C errors.

Signed-off-by: GitHub Copilot <copilot@github.com>

Author: sareluzi

kernel/realsense/d4xx.c

@@ -2177,7 +2177,12 @@ static int ds5_get_hwmc_status(struct ds5 *state)
 		if (retries != 100)
 			msleep_range(1);
 		ret = ds5_read(state, DS5_HWMC_STATUS, &status);
-	} while (!ret && retries-- && status == DS5_HWMC_STATUS_WIP);
+		if (ret) {
+			dev_dbg(&state->client->dev,
+				"%s(): I2C read failed (%d), retries left: %d\n",
+				__func__, ret, retries);
+		}
+	} while (retries-- && (ret || status == DS5_HWMC_STATUS_WIP));
 	dev_dbg(&state->client->dev,
 			"%s(): ret: 0x%x, status: 0x%x\n",
 			__func__, ret, status);
@@ -2730,6 +2735,75 @@ static int ds5_hw_reset_with_recovery(struct ds5 *state)
 				__func__, dev_type, DS5_HW_RESET_TIMEOUT_MS);
 	}
 
+	/* 9. Verify HWMC subsystem is ready to accept commands.
+	 * After HW reset the FW reports 0xDEAD and populates device type
+	 * before the HWM command processor is fully initialized.  If
+	 * userspace queries GVD/HWMC immediately after we return, the
+	 * I2C reads NAK (EREMOTEIO) or return stale status (WIP/ERR),
+	 * which can crash RS Viewer.  Send a lightweight GVD command and
+	 * poll HWMC_STATUS until it completes successfully.
+	 */
+	{
+		struct hwm_cmd hwmc_probe;
+		u16 hwmc_status = DS5_HWMC_STATUS_WIP;
+		int hwmc_ret;
+
+		memcpy(&hwmc_probe, &gvd, sizeof(gvd));
+
+		for (retry = 0; retry < DS5_HW_RESET_MAX_RETRIES; retry++) {
+			hwmc_ret = ds5_raw_write(state, DS5_HWMC_DATA,
+						 &hwmc_probe, sizeof(hwmc_probe));
+			if (hwmc_ret) {
+				dev_dbg(&state->client->dev,
+					"%s(): HWMC probe write failed (%d), retry %d\n",
+					__func__, hwmc_ret, retry);
+				msleep(DS5_HW_RESET_POLL_INTERVAL_MS);
+				continue;
+			}
+
+			hwmc_ret = ds5_write(state, DS5_HWMC_EXEC, 0x01);
+			if (hwmc_ret) {
+				dev_dbg(&state->client->dev,
+					"%s(): HWMC probe exec failed (%d), retry %d\n",
+					__func__, hwmc_ret, retry);
+				msleep(DS5_HW_RESET_POLL_INTERVAL_MS);
+				continue;
+			}
+
+			/* Poll status — allow both I2C and WIP retries */
+			{
+				int poll;
+
+				for (poll = 0; poll < 100; poll++) {
+					msleep_range(5);
+					hwmc_ret = ds5_read(state, DS5_HWMC_STATUS,
+							     &hwmc_status);
+					if (hwmc_ret == 0 &&
+					    hwmc_status == DS5_HWMC_STATUS_OK)
+						break;
+				}
+			}
+
+			if (hwmc_ret == 0 && hwmc_status == DS5_HWMC_STATUS_OK) {
+				dev_info(&state->client->dev,
+					"%s(): HWMC ready after %d ms\n",
+					__func__,
+					(retry + 1) * DS5_HW_RESET_POLL_INTERVAL_MS);
+				break;
+			}
+
+			dev_dbg(&state->client->dev,
+				"%s(): HWMC not ready (status: 0x%x, ret: %d), retry %d\n",
+				__func__, hwmc_status, hwmc_ret, retry);
+			msleep(DS5_HW_RESET_POLL_INTERVAL_MS);
+		}
+
+		if (retry >= DS5_HW_RESET_MAX_RETRIES)
+			dev_warn(&state->client->dev,
+				"%s(): HWMC subsystem not ready after %d ms, userspace queries may fail\n",
+				__func__, DS5_HW_RESET_TIMEOUT_MS);
+	}
+
 	dev_info(&state->client->dev,
 		"%s(): HW reset complete. Firmware: %d.%d.%d.%d\n",
 		__func__,
@@ -3126,24 +3200,24 @@ static int ds5_gvd(struct ds5 *state, unsigned char *data)
 	struct hwm_cmd cmd;
 	int ret = -1;
 	u16 length = 0;
-	u16 status = 2;
-	u8 retries = 3;
+	u16 status = DS5_HWMC_STATUS_WIP;
+	u8 retries = 20;
 
 	memcpy(&cmd, &gvd, sizeof(gvd));
 	ds5_raw_write_with_check(state, DS5_HWMC_DATA, &cmd, sizeof(cmd)); /* Write command data */
 	ds5_write_with_check(state, DS5_HWMC_EXEC, 0x01); /* execute cmd */
 	do {
-		if (retries != 3)
-			msleep_range(10);
+		if (retries != 20)
+			msleep_range(50);
 
 		ret = ds5_read(state, DS5_HWMC_STATUS, &status);
-	} while (ret && retries-- && status != 0);
+	} while ((ret || status == DS5_HWMC_STATUS_WIP) && retries--);
 
-	if (ret || status != 0) {
+	if (ret || status != DS5_HWMC_STATUS_OK) {
 		dev_err(&state->client->dev,
-				"%s(): Failed to read GVD, HWM cmd status: %x\n",
-				__func__, status);
-		return status;
+				"%s(): Failed to read GVD, HWM cmd status: %x, ret: %d\n",
+				__func__, status, ret);
+		return -EIO;
 	}
 
 	ret = ds5_raw_read(state, DS5_HWMC_RESP_LEN, &length, sizeof(length)); /* Read response length */