diff --git a/src/xrt/auxiliary/util/u_device.c b/src/xrt/auxiliary/util/u_device.c
index 5a5babee7..4a4f664b1 100644
--- a/src/xrt/auxiliary/util/u_device.c
+++ b/src/xrt/auxiliary/util/u_device.c
@@ -527,10 +527,11 @@ u_device_ni_get_hand_tracking(struct xrt_device *xdev,
 	return XRT_ERROR_NOT_IMPLEMENTED;
 }
 
-void
+xrt_result_t
 u_device_ni_set_output(struct xrt_device *xdev, enum xrt_output_name name, const struct xrt_output_value *value)
 {
-	E(get_hand_tracking);
+	E(set_output);
+	return XRT_ERROR_NOT_IMPLEMENTED;
 }
 
 xrt_result_t
diff --git a/src/xrt/auxiliary/util/u_device.h b/src/xrt/auxiliary/util/u_device.h
index 480efedeb..7a469d512 100644
--- a/src/xrt/auxiliary/util/u_device.h
+++ b/src/xrt/auxiliary/util/u_device.h
@@ -226,7 +226,7 @@ u_device_ni_get_hand_tracking(struct xrt_device *xdev,
  *
  * @ingroup aux_util
  */
-void
+xrt_result_t
 u_device_ni_set_output(struct xrt_device *xdev, enum xrt_output_name name, const struct xrt_output_value *value);
 
 /*!
diff --git a/src/xrt/drivers/ht_ctrl_emu/ht_ctrl_emu.cpp b/src/xrt/drivers/ht_ctrl_emu/ht_ctrl_emu.cpp
index b16b9a20d..219ab98f2 100644
--- a/src/xrt/drivers/ht_ctrl_emu/ht_ctrl_emu.cpp
+++ b/src/xrt/drivers/ht_ctrl_emu/ht_ctrl_emu.cpp
@@ -368,12 +368,6 @@ cemu_device_get_tracked_pose(struct xrt_device *xdev,
 	return xret;
 }
 
-static void
-cemu_device_set_output(struct xrt_device *xdev, enum xrt_output_name name, const struct xrt_output_value *value)
-{
-	// No-op, needed to avoid crash.
-}
-
 //! @todo This is flickery; investigate once we get better hand tracking
 static void
 decide(xrt_vec3 one, xrt_vec3 two, bool *out)
@@ -457,7 +451,7 @@ cemu_devices_create(struct xrt_device *head, struct xrt_device *hands, struct xr
 
 		cemud[i]->base.update_inputs = cemu_device_update_inputs;
 		cemud[i]->base.get_tracked_pose = cemu_device_get_tracked_pose;
-		cemud[i]->base.set_output = cemu_device_set_output;
+		cemud[i]->base.set_output = u_device_ni_set_output;
 		cemud[i]->base.get_hand_tracking = cemu_device_get_hand_tracking;
 		cemud[i]->base.destroy = cemu_device_destroy;
 
diff --git a/src/xrt/drivers/hydra/hydra_driver.c b/src/xrt/drivers/hydra/hydra_driver.c
index d4bbcae53..6f4c508bb 100644
--- a/src/xrt/drivers/hydra/hydra_driver.c
+++ b/src/xrt/drivers/hydra/hydra_driver.c
@@ -793,7 +793,7 @@ hydra_found(struct xrt_prober *xp,
 		hd->base.destroy = hydra_device_destroy;
 		hd->base.update_inputs = hydra_device_update_inputs;
 		hd->base.get_tracked_pose = hydra_device_get_tracked_pose;
-		// hs->base.set_output = hydra_device_set_output;
+		hd->base.set_output = u_device_ni_set_output;
 		hd->base.name = XRT_DEVICE_HYDRA;
 		snprintf(hd->base.str, XRT_DEVICE_NAME_LEN, "%s %i", "Razer Hydra Controller", (int)(i + 1));
 		snprintf(hd->base.serial, XRT_DEVICE_NAME_LEN, "%s%i", "RZRHDRC", (int)(i + 1));
diff --git a/src/xrt/drivers/multi_wrapper/multi.c b/src/xrt/drivers/multi_wrapper/multi.c
index 6e862c8a9..414eff097 100644
--- a/src/xrt/drivers/multi_wrapper/multi.c
+++ b/src/xrt/drivers/multi_wrapper/multi.c
@@ -185,12 +185,12 @@ get_hand_tracking(struct xrt_device *xdev,
 	return XRT_SUCCESS;
 }
 
-static void
+static xrt_result_t
 set_output(struct xrt_device *xdev, enum xrt_output_name name, const struct xrt_output_value *value)
 {
 	struct multi_device *d = (struct multi_device *)xdev;
 	struct xrt_device *target = d->tracking_override.target;
-	xrt_device_set_output(target, name, value);
+	return xrt_device_set_output(target, name, value);
 }
 
 static xrt_result_t
diff --git a/src/xrt/drivers/ohmd/oh_device.c b/src/xrt/drivers/ohmd/oh_device.c
index 250d902b7..af6642bd2 100644
--- a/src/xrt/drivers/ohmd/oh_device.c
+++ b/src/xrt/drivers/ohmd/oh_device.c
@@ -326,7 +326,7 @@ oh_device_update_inputs(struct xrt_device *xdev)
 	return XRT_SUCCESS;
 }
 
-static void
+static xrt_result_t
 oh_device_set_output(struct xrt_device *xdev, enum xrt_output_name name, const struct xrt_output_value *value)
 {
 	struct oh_device *ohd = oh_device(xdev);
@@ -342,12 +342,16 @@ oh_device_set_output(struct xrt_device *xdev, enum xrt_output_name name, const s
 		frequency = DEFAULT_HAPTIC_FREQ;
 	}
 
-	ohmd_device_set_haptics_on(ohd->dev, (float)value->vibration.duration_ns / 1e9f, frequency,
-	                           value->vibration.amplitude);
+	int result = ohmd_device_set_haptics_on(ohd->dev, (float)value->vibration.duration_ns / 1e9f, frequency,
+	                                        value->vibration.amplitude);
+	if (result == -1) {
+		return XRT_ERROR_OUTPUT_REQUEST_FAILURE;
+	}
 #else
 	// There is no official OpenHMD Haptic API.
 	(void)ohd;
 #endif
+	return XRT_SUCCESS;
 }
 
 static bool
diff --git a/src/xrt/drivers/opengloves/opengloves_device.c b/src/xrt/drivers/opengloves/opengloves_device.c
index 97ad6e32b..0784dec14 100644
--- a/src/xrt/drivers/opengloves/opengloves_device.c
+++ b/src/xrt/drivers/opengloves/opengloves_device.c
@@ -174,7 +174,7 @@ opengloves_ffb_location_convert(const struct xrt_output_force_feedback *xrt_ffb,
 	}
 }
 
-static void
+static xrt_result_t
 opengloves_device_set_output(struct xrt_device *xdev, enum xrt_output_name name, const struct xrt_output_value *value)
 {
 	struct opengloves_device *od = opengloves_device(xdev);
@@ -194,9 +194,16 @@ opengloves_device_set_output(struct xrt_device *xdev, enum xrt_output_name name,
 		char buff[64];
 		opengloves_alpha_encoding_encode(&out, buff);
 
-		opengloves_communication_device_write(od->ocd, buff, strlen(buff));
+		int ret = opengloves_communication_device_write(od->ocd, buff, strlen(buff));
+		if (ret == -1) {
+			return XRT_ERROR_OUTPUT_REQUEST_FAILURE;
+		}
+		return XRT_SUCCESS;
 	}
-	default: break;
+	default:
+		U_LOG_XDEV_UNSUPPORTED_OUTPUT(&od->base, od->log_level, name);
+		return XRT_ERROR_OUTPUT_UNSUPPORTED;
+		break;
 	}
 }
 
diff --git a/src/xrt/drivers/psmv/psmv_driver.c b/src/xrt/drivers/psmv/psmv_driver.c
index cd42c415b..521b168e1 100644
--- a/src/xrt/drivers/psmv/psmv_driver.c
+++ b/src/xrt/drivers/psmv/psmv_driver.c
@@ -921,13 +921,14 @@ amp_scale(struct psmv_device *psmv, float amp)
 	return amp * (max - min) + min;
 }
 
-static void
+static xrt_result_t
 psmv_device_set_output(struct xrt_device *xdev, enum xrt_output_name name, const struct xrt_output_value *value)
 {
 	struct psmv_device *psmv = psmv_device(xdev);
 
 	if (name != XRT_OUTPUT_NAME_PSMV_RUMBLE_VIBRATION) {
-		return;
+		U_LOG_XDEV_UNSUPPORTED_OUTPUT(&psmv->base, psmv->log_level, name);
+		return XRT_ERROR_OUTPUT_UNSUPPORTED;
 	}
 
 	os_mutex_lock(&psmv->lock);
@@ -944,6 +945,7 @@ psmv_device_set_output(struct xrt_device *xdev, enum xrt_output_name name, const
 	psmv_led_and_trigger_update_locked(psmv, now);
 
 	os_mutex_unlock(&psmv->lock);
+	return XRT_SUCCESS;
 }
 
 
diff --git a/src/xrt/drivers/pssense/pssense_driver.c b/src/xrt/drivers/pssense/pssense_driver.c
index 5b35992d2..2a8f0819c 100644
--- a/src/xrt/drivers/pssense/pssense_driver.c
+++ b/src/xrt/drivers/pssense/pssense_driver.c
@@ -676,7 +676,7 @@ pssense_device_update_inputs(struct xrt_device *xdev)
 	return XRT_SUCCESS;
 }
 
-static void
+static xrt_result_t
 pssense_set_output(struct xrt_device *xdev, enum xrt_output_name name, const struct xrt_output_value *value)
 {
 	struct pssense_device *pssense = (struct pssense_device *)xdev;
@@ -710,8 +710,8 @@ pssense_set_output(struct xrt_device *xdev, enum xrt_output_name name, const str
 			}
 		}
 	} else {
-		PSSENSE_ERROR(pssense, "Unknown output name requested %u", name);
-		return;
+		U_LOG_XDEV_UNSUPPORTED_OUTPUT(&pssense->base, pssense->log_level, name);
+		return XRT_ERROR_OUTPUT_UNSUPPORTED;
 	}
 
 	os_mutex_lock(&pssense->lock);
@@ -730,6 +730,8 @@ pssense_set_output(struct xrt_device *xdev, enum xrt_output_name name, const str
 		pssense_send_output_report_locked(pssense);
 	}
 	os_mutex_unlock(&pssense->lock);
+
+	return XRT_SUCCESS;
 }
 
 static void
diff --git a/src/xrt/drivers/qwerty/qwerty_device.c b/src/xrt/drivers/qwerty/qwerty_device.c
index 53949d3b9..b390af901 100644
--- a/src/xrt/drivers/qwerty/qwerty_device.c
+++ b/src/xrt/drivers/qwerty/qwerty_device.c
@@ -177,7 +177,7 @@ qwerty_update_inputs(struct xrt_device *xd)
 	return XRT_SUCCESS;
 }
 
-static void
+static xrt_result_t
 qwerty_set_output(struct xrt_device *xd, enum xrt_output_name name, const struct xrt_output_value *value)
 {
 	struct qwerty_device *qd = qwerty_device(xd);
@@ -190,6 +190,8 @@ qwerty_set_output(struct xrt_device *xd, enum xrt_output_name name, const struct
 		            "\tfrequency=%.2f amplitude=%.2f duration=%" PRId64,
 		            xd->str, frequency, amplitude, duration);
 	}
+
+	return XRT_SUCCESS;
 }
 
 static xrt_result_t
diff --git a/src/xrt/drivers/remote/r_device.c b/src/xrt/drivers/remote/r_device.c
index d795e0176..7f8b4d745 100644
--- a/src/xrt/drivers/remote/r_device.c
+++ b/src/xrt/drivers/remote/r_device.c
@@ -179,13 +179,6 @@ r_device_get_hand_tracking(struct xrt_device *xdev,
 	return XRT_SUCCESS;
 }
 
-static void
-r_device_set_output(struct xrt_device *xdev, enum xrt_output_name name, const struct xrt_output_value *value)
-{
-	struct r_device *rd = r_device(xdev);
-	(void)rd;
-}
-
 /*!
  * @public @memberof r_device
  */
@@ -204,7 +197,7 @@ r_device_create(struct r_hub *r, bool is_left)
 	rd->base.get_tracked_pose = r_device_get_tracked_pose;
 	rd->base.get_hand_tracking = r_device_get_hand_tracking;
 	rd->base.get_view_poses = u_device_ni_get_view_poses;
-	rd->base.set_output = r_device_set_output;
+	rd->base.set_output = u_device_ni_set_output;
 	rd->base.destroy = r_device_destroy;
 	rd->base.tracking_origin = &r->origin;
 	rd->base.supported.orientation_tracking = true;
diff --git a/src/xrt/drivers/remote/r_hmd.c b/src/xrt/drivers/remote/r_hmd.c
index 374fea43f..88f1e7049 100644
--- a/src/xrt/drivers/remote/r_hmd.c
+++ b/src/xrt/drivers/remote/r_hmd.c
@@ -108,12 +108,6 @@ r_hmd_get_view_poses(struct xrt_device *xdev,
 	return XRT_SUCCESS;
 }
 
-static void
-r_hmd_set_output(struct xrt_device *xdev, enum xrt_output_name name, const struct xrt_output_value *value)
-{
-	// Empty
-}
-
 /*!
  * @public @memberof r_hmd
  */
@@ -132,7 +126,7 @@ r_hmd_create(struct r_hub *r)
 	rh->base.get_tracked_pose = r_hmd_get_tracked_pose;
 	rh->base.get_hand_tracking = u_device_ni_get_hand_tracking;
 	rh->base.get_view_poses = r_hmd_get_view_poses;
-	rh->base.set_output = r_hmd_set_output;
+	rh->base.set_output = u_device_ni_set_output;
 	rh->base.destroy = r_hmd_destroy;
 	rh->base.tracking_origin = &r->origin;
 	rh->base.supported.orientation_tracking = true;
diff --git a/src/xrt/drivers/rift_s/rift_s_controller.c b/src/xrt/drivers/rift_s/rift_s_controller.c
index c4fc81682..f6146f7fb 100644
--- a/src/xrt/drivers/rift_s/rift_s_controller.c
+++ b/src/xrt/drivers/rift_s/rift_s_controller.c
@@ -509,12 +509,6 @@ rift_s_controller_update_inputs(struct xrt_device *xdev)
 	return XRT_SUCCESS;
 }
 
-static void
-rift_s_controller_set_output(struct xrt_device *xdev, enum xrt_output_name name, const struct xrt_output_value *value)
-{
-	/* TODO: Implement haptic sending */
-}
-
 static void
 rift_s_controller_get_fusion_pose(struct rift_s_controller *ctrl,
                                   enum xrt_input_name name,
@@ -613,7 +607,7 @@ rift_s_controller_create(struct rift_s_system *sys, enum xrt_device_type device_
 	os_mutex_init(&ctrl->mutex);
 
 	ctrl->base.update_inputs = rift_s_controller_update_inputs;
-	ctrl->base.set_output = rift_s_controller_set_output;
+	ctrl->base.set_output = u_device_ni_set_output;
 	ctrl->base.get_tracked_pose = rift_s_controller_get_tracked_pose;
 	ctrl->base.get_view_poses = u_device_get_view_poses;
 	ctrl->base.destroy = rift_s_controller_destroy;
diff --git a/src/xrt/drivers/simulated/simulated_controller.c b/src/xrt/drivers/simulated/simulated_controller.c
index 8a8a76f07..a6f284fcf 100644
--- a/src/xrt/drivers/simulated/simulated_controller.c
+++ b/src/xrt/drivers/simulated/simulated_controller.c
@@ -166,13 +166,6 @@ simulated_device_get_tracked_pose(struct xrt_device *xdev,
 	return XRT_SUCCESS;
 }
 
-static void
-simulated_device_set_output(struct xrt_device *xdev, enum xrt_output_name name, const struct xrt_output_value *value)
-{
-	struct simulated_device *sd = simulated_device(xdev);
-	(void)sd;
-}
-
 
 /*
  *
@@ -358,7 +351,7 @@ simulated_create_controller(enum xrt_device_name name,
 	sd->base.get_tracked_pose = simulated_device_get_tracked_pose;
 	sd->base.get_hand_tracking = u_device_ni_get_hand_tracking;
 	sd->base.get_view_poses = u_device_ni_get_view_poses;
-	sd->base.set_output = simulated_device_set_output;
+	sd->base.set_output = u_device_ni_set_output;
 	sd->base.destroy = simulated_device_destroy;
 	sd->base.tracking_origin = origin;
 	sd->base.supported.orientation_tracking = true;
diff --git a/src/xrt/drivers/steamvr_lh/device.cpp b/src/xrt/drivers/steamvr_lh/device.cpp
index 959c42f96..90e0a6e2a 100644
--- a/src/xrt/drivers/steamvr_lh/device.cpp
+++ b/src/xrt/drivers/steamvr_lh/device.cpp
@@ -187,9 +187,7 @@ ControllerDevice::ControllerDevice(vr::PropertyContainerHandle_t handle, const D
 
 	this->xrt_device::get_hand_tracking =
 	    &device_bouncer<ControllerDevice, &ControllerDevice::get_hand_tracking, xrt_result_t>;
-#define SETUP_MEMBER_FUNC(name) this->xrt_device::name = &device_bouncer<ControllerDevice, &ControllerDevice::name>
-	SETUP_MEMBER_FUNC(set_output);
-#undef SETUP_MEMBER_FUNC
+	this->xrt_device::set_output = &device_bouncer<ControllerDevice, &ControllerDevice::set_output, xrt_result_t>;
 }
 
 Device::~Device()
@@ -461,13 +459,13 @@ ControllerDevice::get_tracked_pose(xrt_input_name name, uint64_t at_timestamp_ns
 	return XRT_SUCCESS;
 }
 
-void
+xrt_result_t
 ControllerDevice::set_output(xrt_output_name name, const xrt_output_value *value)
 
 {
 	const auto &vib = value->vibration;
 	if (vib.amplitude == 0.0)
-		return;
+		return XRT_SUCCESS;
 	vr::VREvent_HapticVibration_t event;
 	event.containerHandle = container_handle;
 	event.componentHandle = haptic_handle;
@@ -478,6 +476,7 @@ ControllerDevice::set_output(xrt_output_name name, const xrt_output_value *value
 	event.fAmplitude = vib.amplitude;
 
 	ctx->add_haptic_event(event);
+	return XRT_SUCCESS;
 }
 
 void
diff --git a/src/xrt/drivers/steamvr_lh/device.hpp b/src/xrt/drivers/steamvr_lh/device.hpp
index 1aac23d9b..9a5ae17f5 100644
--- a/src/xrt/drivers/steamvr_lh/device.hpp
+++ b/src/xrt/drivers/steamvr_lh/device.hpp
@@ -162,7 +162,7 @@ class ControllerDevice : public Device
 public:
 	ControllerDevice(vr::PropertyContainerHandle_t container_handle, const DeviceBuilder &builder);
 
-	void
+	xrt_result_t
 	set_output(xrt_output_name name, const xrt_output_value *value);
 
 	void
diff --git a/src/xrt/drivers/survive/survive_driver.c b/src/xrt/drivers/survive/survive_driver.c
index 37b315306..a553a5700 100644
--- a/src/xrt/drivers/survive/survive_driver.c
+++ b/src/xrt/drivers/survive/survive_driver.c
@@ -404,7 +404,7 @@ survive_controller_haptic_pulse(struct survive_device *survive, const struct xrt
 	                                    duration_seconds);
 }
 
-static void
+static xrt_result_t
 survive_controller_device_set_output(struct xrt_device *xdev,
                                      enum xrt_output_name name,
                                      const struct xrt_output_value *value)
@@ -412,20 +412,23 @@ survive_controller_device_set_output(struct xrt_device *xdev,
 	struct survive_device *survive = (struct survive_device *)xdev;
 
 	if (name != XRT_OUTPUT_NAME_VIVE_HAPTIC && name != XRT_OUTPUT_NAME_INDEX_HAPTIC) {
-		SURVIVE_ERROR(survive, "Unknown output");
-		return;
+		U_LOG_XDEV_UNSUPPORTED_OUTPUT(&survive->base, survive->sys->log_level, name);
+		return XRT_ERROR_OUTPUT_UNSUPPORTED;
 	}
 
 	bool pulse = value->vibration.amplitude > 0.01;
 	if (!pulse) {
-		return;
+		return XRT_SUCCESS;
 	}
 
 	int ret = survive_controller_haptic_pulse(survive, value);
 
 	if (ret != 0) {
 		SURVIVE_ERROR(survive, "haptic failed %d", ret);
+		return XRT_ERROR_OUTPUT_REQUEST_FAILURE;
 	}
+
+	return XRT_SUCCESS;
 }
 
 struct Button
diff --git a/src/xrt/drivers/vive/vive_controller.c b/src/xrt/drivers/vive/vive_controller.c
index bd12819b0..fd25ff071 100644
--- a/src/xrt/drivers/vive/vive_controller.c
+++ b/src/xrt/drivers/vive/vive_controller.c
@@ -487,7 +487,7 @@ vive_controller_haptic_pulse(struct vive_controller_device *d, const struct xrt_
 	return os_hid_set_feature(d->controller_hid, (uint8_t *)&report, sizeof(report));
 }
 
-static void
+static xrt_result_t
 vive_controller_device_set_output(struct xrt_device *xdev,
                                   enum xrt_output_name name,
                                   const struct xrt_output_value *value)
@@ -495,18 +495,17 @@ vive_controller_device_set_output(struct xrt_device *xdev,
 	struct vive_controller_device *d = vive_controller_device(xdev);
 
 	if (name != XRT_OUTPUT_NAME_VIVE_HAPTIC && name != XRT_OUTPUT_NAME_INDEX_HAPTIC) {
-		VIVE_ERROR(d, "Unknown output\n");
-		return;
+		U_LOG_XDEV_UNSUPPORTED_OUTPUT(&d->base, d->log_level, name);
+		return XRT_ERROR_OUTPUT_UNSUPPORTED;
 	}
 
-	bool pulse = value->vibration.amplitude > 0.01;
-	if (!pulse) {
-		return;
+	if (value->vibration.amplitude > 0.01) {
+		os_mutex_lock(&d->lock);
+		vive_controller_haptic_pulse(d, value);
+		os_mutex_unlock(&d->lock);
 	}
 
-	os_mutex_lock(&d->lock);
-	vive_controller_haptic_pulse(d, value);
-	os_mutex_unlock(&d->lock);
+	return XRT_SUCCESS;
 }
 
 
diff --git a/src/xrt/drivers/wmr/wmr_controller_hp.c b/src/xrt/drivers/wmr/wmr_controller_hp.c
index bb84f222e..8d90f5c87 100644
--- a/src/xrt/drivers/wmr/wmr_controller_hp.c
+++ b/src/xrt/drivers/wmr/wmr_controller_hp.c
@@ -339,15 +339,6 @@ wmr_controller_hp_update_inputs(struct xrt_device *xdev)
 	return XRT_SUCCESS;
 }
 
-static void
-wmr_controller_hp_set_output(struct xrt_device *xdev, enum xrt_output_name name, const struct xrt_output_value *value)
-{
-	DRV_TRACE_MARKER();
-
-	// struct wmr_controller_base *d = wmr_controller_base(xdev);
-	// Todo: implement
-}
-
 static void
 wmr_controller_hp_destroy(struct xrt_device *xdev)
 {
@@ -386,7 +377,7 @@ wmr_controller_hp_create(struct wmr_controller_connection *conn,
 
 	wcb->base.destroy = wmr_controller_hp_destroy;
 	wcb->base.update_inputs = wmr_controller_hp_update_inputs;
-	wcb->base.set_output = wmr_controller_hp_set_output;
+	wcb->base.set_output = u_device_ni_set_output;
 
 	SET_INPUT(wcb, MENU_CLICK, MENU_CLICK);
 	SET_INPUT(wcb, HOME_CLICK, HOME_CLICK);
diff --git a/src/xrt/drivers/wmr/wmr_controller_og.c b/src/xrt/drivers/wmr/wmr_controller_og.c
index 86cde6e03..96380d24e 100644
--- a/src/xrt/drivers/wmr/wmr_controller_og.c
+++ b/src/xrt/drivers/wmr/wmr_controller_og.c
@@ -319,15 +319,6 @@ wmr_controller_og_update_inputs(struct xrt_device *xdev)
 	return XRT_SUCCESS;
 }
 
-static void
-wmr_controller_og_set_output(struct xrt_device *xdev, enum xrt_output_name name, const struct xrt_output_value *value)
-{
-	DRV_TRACE_MARKER();
-
-	// struct wmr_controller_base *d = wmr_controller_base(xdev);
-	// Todo: implement
-}
-
 static void
 wmr_controller_og_destroy(struct xrt_device *xdev)
 {
@@ -363,7 +354,7 @@ wmr_controller_og_create(struct wmr_controller_connection *conn,
 	}
 	wcb->base.destroy = wmr_controller_og_destroy;
 	wcb->base.update_inputs = wmr_controller_og_update_inputs;
-	wcb->base.set_output = wmr_controller_og_set_output;
+	wcb->base.set_output = u_device_ni_set_output;
 
 	if (pid == ODYSSEY_CONTROLLER_PID) {
 		SET_ODYSSEY_INPUT(wcb, MENU_CLICK);
diff --git a/src/xrt/include/xrt/xrt_device.h b/src/xrt/include/xrt/xrt_device.h
index 18a2ce42e..557796603 100644
--- a/src/xrt/include/xrt/xrt_device.h
+++ b/src/xrt/include/xrt/xrt_device.h
@@ -441,7 +441,9 @@ struct xrt_device
 	 * @param[in] value          The value to set the output to.
 	 * @see xrt_output_name
 	 */
-	void (*set_output)(struct xrt_device *xdev, enum xrt_output_name name, const struct xrt_output_value *value);
+	xrt_result_t (*set_output)(struct xrt_device *xdev,
+	                           enum xrt_output_name name,
+	                           const struct xrt_output_value *value);
 
 	/*!
 	 * Gets limits of this devices outputs.
diff --git a/src/xrt/ipc/client/ipc_client_xdev.c b/src/xrt/ipc/client/ipc_client_xdev.c
index 9e012c269..d94ae8ad2 100644
--- a/src/xrt/ipc/client/ipc_client_xdev.c
+++ b/src/xrt/ipc/client/ipc_client_xdev.c
@@ -127,7 +127,7 @@ ipc_client_xdev_get_body_joints(struct xrt_device *xdev,
 	IPC_CHK_ALWAYS_RET(icx->ipc_c, xret, "ipc_call_device_get_body_joints");
 }
 
-static void
+static xrt_result_t
 ipc_client_xdev_set_output(struct xrt_device *xdev, enum xrt_output_name name, const struct xrt_output_value *value)
 {
 	struct ipc_client_xdev *icx = ipc_client_xdev(xdev);
@@ -146,7 +146,7 @@ ipc_client_xdev_set_output(struct xrt_device *xdev, enum xrt_output_name name, c
 		ipc_client_connection_lock(ipc_c);
 
 		xret = ipc_send_device_set_haptic_output_locked(ipc_c, icx->device_id, name, &samples);
-		IPC_CHK_WITH_RET(ipc_c, xret, "ipc_send_device_set_haptic_output_locked", );
+		IPC_CHK_WITH_GOTO(ipc_c, xret, "ipc_send_device_set_haptic_output_locked", send_haptic_output_end);
 
 		xrt_result_t alloc_xret;
 		xret = ipc_receive(&ipc_c->imc, &alloc_xret, sizeof alloc_xret);
@@ -171,6 +171,8 @@ ipc_client_xdev_set_output(struct xrt_device *xdev, enum xrt_output_name name, c
 		xret = ipc_call_device_set_output(ipc_c, icx->device_id, name, value);
 		IPC_CHK_ONLY_PRINT(ipc_c, xret, "ipc_call_device_set_output");
 	}
+
+	return xret;
 }
 
 xrt_result_t