xrt: adapt drivers to new update_input api change

Part-of: <https://gitlab.freedesktop.org/monado/monado/-/merge_requests/2246>

doc/changes/auxiliary/mr.2246.md

···
+Change: `u_device_noop_update_inputs` returns `xrt_result_t`

src/xrt/auxiliary/util/u_device.c

···
  *
  */
 
-void
+xrt_result_t
 u_device_noop_update_inputs(struct xrt_device *xdev)
 {
 	// Empty, should only be used from a device without any inputs.
+	return XRT_SUCCESS;
 }
 
 

src/xrt/auxiliary/util/u_device.h

···
  *
  * @ingroup aux_util
  */
-void
+xrt_result_t
 u_device_noop_update_inputs(struct xrt_device *xdev);
 
 

src/xrt/drivers/arduino/arduino_device.c

···
 	free(ad);
 }
 
-static void
+static xrt_result_t
 arduino_device_update_inputs(struct xrt_device *xdev)
 {
 	struct arduino_device *ad = arduino_device(xdev);
···
 
 	// Done now.
 	os_mutex_unlock(&ad->lock);
+
+	return XRT_SUCCESS;
 }
 
 static void

src/xrt/drivers/daydream/daydream_device.c

···
 	free(daydream);
 }
 
-static void
+static xrt_result_t
 daydream_device_update_inputs(struct xrt_device *xdev)
 {
 	struct daydream_device *daydream = daydream_device(xdev);
···
 	// Done now.
 
 	os_mutex_unlock(&daydream->lock);
+
+	return XRT_SUCCESS;
 }
 
 static void

src/xrt/drivers/ht_ctrl_emu/ht_ctrl_emu.cpp

···
 	*out = (dist < pinch_activation_dist);
 }
 
-static void
+static xrt_result_t
 cemu_device_update_inputs(struct xrt_device *xdev)
 {
 	struct cemu_device *dev = cemu_device(xdev);
···
 
 	xrt_device_get_hand_tracking(dev->sys->in_hand, dev->ht_input_name, os_monotonic_get_ns(), &joint_set, &noop);
 
-
 	if (!joint_set.is_active) {
 		xdev->inputs[CEMU_INDEX_SELECT].value.boolean = false;
 		xdev->inputs[CEMU_INDEX_MENU].value.boolean = false;
-		return;
+		return XRT_SUCCESS;
 	}
 
 	decide(joint_set.values.hand_joint_set_default[XRT_HAND_JOINT_INDEX_TIP].relation.pose.position,
···
 	// For now, all other inputs are off - detecting any gestures more complicated than pinch is too unreliable for
 	// now.
 	xdev->inputs[CEMU_INDEX_MENU].value.boolean = false;
+
+	return XRT_SUCCESS;
 }
 
 

src/xrt/drivers/hydra/hydra_driver.c

···
  *
  */
 
-static void
+static xrt_result_t
 hydra_device_update_inputs(struct xrt_device *xdev)
 {
 	struct hydra_device *hd = hydra_device(xdev);
···
 		// inputs[HYDRA_INDEX_POSE].timestamp = now;
 		// inputs[HYDRA_INDEX_POSE].value.
 	}
+
+	return XRT_SUCCESS;
 }
 
 static void

src/xrt/drivers/multi_wrapper/multi.c

···
 	return target->compute_distortion(target, view, u, v, result);
 }
 
-static void
+static xrt_result_t
 update_inputs(struct xrt_device *xdev)
 {
 	struct multi_device *d = (struct multi_device *)xdev;
 	struct xrt_device *target = d->tracking_override.target;
-	xrt_device_update_inputs(target);
+	return xrt_device_update_inputs(target);
 }
 
 

src/xrt/drivers/ohmd/oh_device.c

···
 	}
 }
 
-static void
+static xrt_result_t
 oh_device_update_inputs(struct xrt_device *xdev)
 {
 	struct oh_device *ohd = oh_device(xdev);
 
 	int control_count;
-	float control_state[256];
+	float control_state[256] = {0};
 
 	ohmd_device_geti(ohd->dev, OHMD_CONTROL_COUNT, &control_count);
 	if (control_count > 64)
···
 	for (int i = 0; i < 256; i++) {
 		ohd->last_control_state[i] = control_state[i];
 	}
+
+	return XRT_SUCCESS;
 }
 
 static void

src/xrt/drivers/opengloves/opengloves_device.c

···
 	out_joint_set->is_active = true;
 }
 
-static void
+static xrt_result_t
 opengloves_device_update_inputs(struct xrt_device *xdev)
 {
 	struct opengloves_device *od = opengloves_device(xdev);
···
 	    od->last_input->joysticks.main.pressed;
 
 	os_mutex_unlock(&od->lock);
+
+	return XRT_SUCCESS;
 }
 
 static void

src/xrt/drivers/psmv/psmv_driver.c

···
 	free(psmv);
 }
 
-static void
+static xrt_result_t
 psmv_device_update_inputs(struct xrt_device *xdev)
 {
 	struct psmv_device *psmv = psmv_device(xdev);
···
 
 	// Done now.
 	os_mutex_unlock(&psmv->lock);
+
+	return XRT_SUCCESS;
 }
 
 static xrt_result_t

src/xrt/drivers/pssense/pssense_driver.c

···
 	free(pssense);
 }
 
-static void
+static xrt_result_t
 pssense_device_update_inputs(struct xrt_device *xdev)
 {
 	struct pssense_device *pssense = (struct pssense_device *)xdev;
···
 
 	// Done now.
 	os_mutex_unlock(&pssense->lock);
+
+	return XRT_SUCCESS;
 }
 
 static void

src/xrt/drivers/psvr/psvr_device.c

···
  *
  */
 
-static void
+static xrt_result_t
 psvr_device_update_inputs(struct xrt_device *xdev)
 {
 	struct psvr_device *psvr = psvr_device(xdev);
···
 	update_leds_if_changed(psvr);
 
 	os_mutex_unlock(&psvr->device_mutex);
+
+	return XRT_SUCCESS;
 }
 
 static void

src/xrt/drivers/qwerty/qwerty_device.c

···
 	return qc;
 }
 
-static void
+static xrt_result_t
 qwerty_update_inputs(struct xrt_device *xd)
 {
-	if (xd->name != XRT_DEVICE_SIMPLE_CONTROLLER) {
-		return;
-	}
+	assert(xd->name == XRT_DEVICE_SIMPLE_CONTROLLER);
 
 	struct qwerty_controller *qc = qwerty_controller(xd);
 	struct qwerty_device *qd = &qc->base;
···
 	xd->inputs[QWERTY_SELECT].timestamp = qc->select_timestamp;
 	xd->inputs[QWERTY_MENU].value.boolean = qc->menu_clicked;
 	xd->inputs[QWERTY_MENU].timestamp = qc->menu_timestamp;
+
+	return XRT_SUCCESS;
 }
 
 static void
···
 
 	xd->inputs[0].name = XRT_INPUT_GENERIC_HEAD_POSE;
 
-	xd->update_inputs = qwerty_update_inputs;
+	xd->update_inputs = u_device_noop_update_inputs;
 	xd->get_tracked_pose = qwerty_get_tracked_pose;
 	xd->get_view_poses = u_device_get_view_poses;
 	xd->destroy = qwerty_destroy;

src/xrt/drivers/remote/r_device.c

···
 	u_device_free(&rd->base);
 }
 
-static void
+static xrt_result_t
 r_device_update_inputs(struct xrt_device *xdev)
 {
 	struct r_device *rd = r_device(xdev);
···
 	uint64_t now = os_monotonic_get_ns();
 	struct r_remote_controller_data *latest = rd->is_left ? &r->latest.left : &r->latest.right;
 
+	// TODO: refactor those loops into one
 	if (!latest->active) {
 		for (uint32_t i = 0; i < xdev->input_count; i++) {
 			xdev->inputs[i].active = false;
 			xdev->inputs[i].timestamp = now;
 			U_ZERO(&xdev->inputs[i].value);
 		}
-		return;
+		return XRT_SUCCESS;
 	}
 
 	for (uint32_t i = 0; i < xdev->input_count; i++) {
···
 	xdev->inputs[15].value.vec1    = latest->trackpad_force;
 	xdev->inputs[16].value.boolean = latest->trackpad_touch;
 	// clang-format on
+
+	return XRT_SUCCESS;
 }
 
 static void

src/xrt/drivers/rift_s/rift_s_controller.c

···
 	ctrl->base.inputs[index].value.vec2.y = y;
 }
 
-static void
+static xrt_result_t
 rift_s_controller_update_inputs(struct xrt_device *xdev)
 {
 	struct rift_s_controller *ctrl = (struct rift_s_controller *)(xdev);
···
 	/* FIXME: Output touch detections:
 	      OCULUS_TOUCH_THUMBREST_TOUCH, - does Rift S have a thumbrest?
 	*/
+	os_mutex_unlock(&ctrl->mutex);
 
-	os_mutex_unlock(&ctrl->mutex);
+	return XRT_SUCCESS;
 }
 
 static void

src/xrt/drivers/sample/sample_hmd.c

···
 	u_device_free(&hmd->base);
 }
 
-static void
+static xrt_result_t
 sample_hmd_update_inputs(struct xrt_device *xdev)
 {
 	/*
···
 	 * put code to update the attached inputs fields. If not you can use
 	 * the u_device_noop_update_inputs helper to make it a no-op.
 	 */
+	return XRT_SUCCESS;
 }
 
 static void

src/xrt/drivers/simulated/simulated_controller.c

···
 	u_device_free(&sd->base);
 }
 
-static void
+static xrt_result_t
 simulated_device_update_inputs(struct xrt_device *xdev)
 {
 	struct simulated_device *sd = simulated_device(xdev);
 
 	uint64_t now = os_monotonic_get_ns();
 
+	// TODO refactor those loops into one
 	if (!sd->active) {
 		for (uint32_t i = 0; i < xdev->input_count; i++) {
 			xdev->inputs[i].active = false;
 			xdev->inputs[i].timestamp = now;
 			U_ZERO(&xdev->inputs[i].value);
 		}
-		return;
+		return XRT_SUCCESS;
 	}
 
 	for (uint32_t i = 0; i < xdev->input_count; i++) {
 		xdev->inputs[i].active = true;
 		xdev->inputs[i].timestamp = now;
 	}
+
+	return XRT_SUCCESS;
 }
 
 static void

src/xrt/drivers/steamvr_lh/device.cpp

···
 	this->form_factor_check_supported = false;
 	this->battery_status_supported = true;
 
+	this->xrt_device::update_inputs = &device_bouncer<Device, &Device::update_inputs, xrt_result_t>;
 #define SETUP_MEMBER_FUNC(name) this->xrt_device::name = &device_bouncer<Device, &Device::name>
-	SETUP_MEMBER_FUNC(update_inputs);
 	SETUP_MEMBER_FUNC(get_tracked_pose);
 	SETUP_MEMBER_FUNC(get_battery_status);
 #undef SETUP_MEMBER_FUNC
···
 	this->outputs = output.get();
 }
 
-void
+xrt_result_t
 Device::update_inputs()
 {
 	std::lock_guard<std::mutex> lock(frame_mutex);
 	ctx->maybe_run_frame(++current_frame);
+	return XRT_SUCCESS;
 }
 
 IndexFingerInput *

src/xrt/drivers/steamvr_lh/device.hpp

···
 	xrt_input *
 	get_input_from_name(std::string_view name);
 
-	void
+	xrt_result_t
 	update_inputs();
 
 	void

src/xrt/drivers/survive/survive_driver.c

···
 	}
 }
 
-static void
+static xrt_result_t
 survive_device_update_inputs(struct xrt_device *xdev)
 {
 	struct survive_device *survive = (struct survive_device *)xdev;
···
 	}
 
 	os_mutex_unlock(&survive->sys->lock);
+
+	return XRT_SUCCESS;
 }
 
 static bool

src/xrt/drivers/vive/vive_controller.c

···
 	free(d);
 }
 
-static void
+static xrt_result_t
 vive_controller_device_wand_update_inputs(struct xrt_device *xdev)
 {
 	struct vive_controller_device *d = vive_controller_device(xdev);
···
 	VIVE_TRACE(d, "Trigger: %f", d->state.trigger);
 
 	os_mutex_unlock(&d->lock);
+
+	return XRT_SUCCESS;
 }
 
-static void
+static xrt_result_t
 vive_controller_device_index_update_inputs(struct xrt_device *xdev)
 {
 	XRT_TRACE_MARKER();
···
 	}
 
 	os_mutex_unlock(&d->lock);
+
+	return XRT_SUCCESS;
 }
 
 static void

src/xrt/drivers/vive/vive_device.c

···
 	u_device_free(&d->base);
 }
 
-static void
+static xrt_result_t
 vive_device_update_inputs(struct xrt_device *xdev)
 {
 	XRT_TRACE_MARKER();
 
 	struct vive_device *d = vive_device(xdev);
 	VIVE_TRACE(d, "ENTER!");
+
+	return XRT_SUCCESS;
 }
 
 static void

src/xrt/drivers/wmr/wmr_controller_hp.c

···
 	return b;
 }
 
-static void
+static xrt_result_t
 wmr_controller_hp_update_inputs(struct xrt_device *xdev)
 {
 	DRV_TRACE_MARKER();
···
 	xrt_inputs[WMR_CONTROLLER_INDEX_THUMBSTICK].value.vec2 = cur_inputs->thumbstick.values;
 
 	os_mutex_unlock(&wcb->data_lock);
+
+	return XRT_SUCCESS;
 }
 
 static void

src/xrt/drivers/wmr/wmr_controller_og.c

···
 	return b;
 }
 
-static void
+static xrt_result_t
 wmr_controller_og_update_inputs(struct xrt_device *xdev)
 {
 	DRV_TRACE_MARKER();
···
 	xrt_inputs[WMR_CONTROLLER_INDEX_TRACKPAD].value.vec2 = cur_inputs->trackpad.values;
 
 	os_mutex_unlock(&wcb->data_lock);
+
+	return XRT_SUCCESS;
 }
 
 static void

src/xrt/drivers/xreal_air/xreal_air_hmd.c

···
  *
  */
 
-static void
+static xrt_result_t
 xreal_air_hmd_update_inputs(struct xrt_device *xdev)
 {
 	struct xreal_air_hmd *hmd = xreal_air_hmd(xdev);
···
 	adjust_display_mode(hmd);
 
 	os_mutex_unlock(&hmd->device_mutex);
+
+	return XRT_SUCCESS;
 }
 
 static void

src/xrt/include/xrt/xrt_device.h

···
 	 *
 	 * @param[in] xdev        The device.
 	 */
-	void (*update_inputs)(struct xrt_device *xdev);
+	xrt_result_t (*update_inputs)(struct xrt_device *xdev);
 
 	/*!
 	 * @brief Get relationship of a tracked device to the tracking origin
···
 static inline xrt_result_t
 xrt_device_update_inputs(struct xrt_device *xdev)
 {
-	xdev->update_inputs(xdev);
-	return XRT_SUCCESS;
+	return xdev->update_inputs(xdev);
 }
 
 /*!

src/xrt/ipc/client/ipc_client_device.c

···
 	u_device_free(&icd->base);
 }
 
-static void
+static xrt_result_t
 ipc_client_device_update_inputs(struct xrt_device *xdev)
 {
 	ipc_client_device_t *icd = ipc_client_device(xdev);
 
 	xrt_result_t xret = ipc_call_device_update_input(icd->ipc_c, icd->device_id);
-	IPC_CHK_ONLY_PRINT(icd->ipc_c, xret, "ipc_call_device_update_input");
+	IPC_CHK_ALWAYS_RET(icd->ipc_c, xret, "ipc_call_device_update_input");
 }
 
 static void

src/xrt/ipc/client/ipc_client_hmd.c

···
 	u_device_free(&ich->base);
 }
 
-static void
+static xrt_result_t
 ipc_client_hmd_update_inputs(struct xrt_device *xdev)
 {
 	ipc_client_hmd_t *ich = ipc_client_hmd(xdev);
 
 	xrt_result_t xret = ipc_call_device_update_input(ich->ipc_c, ich->device_id);
-	IPC_CHK_ONLY_PRINT(ich->ipc_c, xret, "ipc_call_device_update_input");
+	IPC_CHK_ALWAYS_RET(ich->ipc_c, xret, "ipc_call_device_update_input");
 }
 
 static void

src/xrt/ipc/server/ipc_server_handler.c

···
 	struct ipc_shared_device *isdev = &ism->isdevs[device_id];
 
 	// Update inputs.
-	xrt_device_update_inputs(xdev);
+	xrt_result_t xret = xrt_device_update_inputs(xdev);
+	if (xret != XRT_SUCCESS) {
+		IPC_ERROR(ics->server, "Failed to update input");
+		return xret;
+	}
 
 	// Copy data into the shared memory.
 	struct xrt_input *src = xdev->inputs;