Merge remote-tracking branch cros/main into firmware-fpmcu-bloonchipper-releasefirmware-fpmcu-bloonchipper-release

Generated by: ./util/update_release_branch.py --board bloonchipper
--relevant_paths_file ./util/fingerprint-relevant-paths.txt firmware-
fpmcu-bloonchipper-release

Relevant changes:

git log --oneline e5fb0b9ba4..28712dae9d -- board/hatch_fp
board/bloonchipper common/fpsensor docs/fingerprint driver/fingerprint
util/getversion.sh

ded9307b79 util/getversion.sh: Fix version when not in a git repo
956055e692 board: change Google USB vendor info
71b2ef709d Update license boilerplate text in source code files
33e11afda0 Revert "fpsensor: Build fpsensor source file with C++"
c8d0360723 fpsensor: Build fpsensor source file with C++
bc113abd53 fpsensor: Fix g++ compiler error
150a58a0dc fpsensor: Fix fp_set_sensor_mode return type
b33b5ce85b fpsensor: Remove nested designators for C++ compatibility
2e864b2539 tree-wide: const-ify argv for console commands
56d8b360f9 test: Add test for get ikm failure when seed not set
3a3d6c3690 test: Add test for fpsensor trivial key failure
233e6bbd08 fpsensor_crypto: Abstract calls to hmac_SHA256
0a041b285b docs/fingerprint: Typo correction
c03fab67e2 docs/fingerprint: Fix the path of fputils.py
0b5d4baf5a util/getversion.sh: Fix empty file list handling
6e128fe760 FPMCU dev board environment with Satlab
3eb29b6aa5 builtin: Move ssize_t to sys/types.h
345d62ebd1 docs/fingerprint: Update power numbers for latest dartmonkey release
c25ffdb316 common: Conditionally support printf %l and %i modifiers
9a3c514b45 test: Add a test to check if the debugger is connected
54e603413f Move standard library tests to their own file
43fa6b4bf8 docs/fingerprint: Update power numbers for latest bloonchipper release
25536f9a84 driver/fingerprint/fpc/bep/fpc_sensor_spi.c: Format with clang-format
4face99efd driver/fingerprint/fpc/libfp/fpc_sensor_pal.h: Format with clang-format
738de2b575 trng: Rename rand to trng_rand
14b8270edd docs/fingerprint: Update dragonclaw power numbers
0b268f93d1 driver/fingerprint/fpc/libfp/fpc_private.c: Format with clang-format
f80da163f2 driver/fingerprint/fpc/libfp/fpc_private.h: Format with clang-format
5e9c85c9b1 driver/fingerprint/fpc/libfp/fpc_sensor_pal.c: Format with clang-format
c1f9dd3cf8 driver/fingerprint/fpc/libfp/fpc_bio_algorithm.h: Format with clang-format
eb1e1bed8d driver/fingerprint/fpc/libfp/fpc1145_private.h: Format with clang-format
6e7b611821 driver/fingerprint/fpc/bep/fpc_bio_algorithm.h: Format with clang-format
e0589cd5e2 driver/fingerprint/fpc/bep/fpc1035_private.h: Format with clang-format
7905e556a0 common/fpsensor/fpsensor_crypto.c: Format with clang-format
21289d170c driver/fingerprint/fpc/bep/fpc1025_private.h: Format with clang-format
98a20f937e common/fpsensor/fpsensor_state.c: Format with clang-format
a2d255d8af common/fpsensor/fpsensor.c: Format with clang-format
73055eeb3f driver/fingerprint/fpc/bep/fpc_private.c: Format with clang-format
0f7b5cb509 common/fpsensor/fpsensor_private.h: Format with clang-format
1ceade6e65 driver/fingerprint/fpc/bep/fpc_private.h: Format with clang-format
dc3e9008b8 board/hatch_fp/board.h: Format with clang-format
dca9d74321 Revert "trng: Rename rand to trng_rand"
a6b0b3554f trng: Rename rand to trng_rand
28d0b75b70 third_party/boringssl: Remove unused header

BRANCH=None
BUG=b:246424843 b:234181908 b:244781166 b:234181908 b:244387210
BUG=b:242720240 chromium:1098010 b:180945056 b:236025198 b:234181908
BUG=b:234181908 b:237344361 b:131913998 b:236386294 b:234143158
BUG=b:234781655 b:215613183 b:242720910
TEST=`make -j buildall`
TEST=./test/run_device_tests.py --board bloonchipper
     Test "aes": PASSED
     Test "cec": PASSED
     Test "cortexm_fpu": PASSED
     Test "crc": PASSED
     Test "flash_physical": PASSED
     Test "flash_write_protect": PASSED
     Test "fpsensor_hw": PASSED
     Test "fpsensor_spi_ro": PASSED
     Test "fpsensor_spi_rw": PASSED
     Test "fpsensor_uart_ro": PASSED
     Test "fpsensor_uart_rw": PASSED
     Test "mpu_ro": PASSED
     Test "mpu_rw": PASSED
     Test "mutex": PASSED
     Test "pingpong": PASSED
     Test "printf": PASSED
     Test "queue": PASSED
     Test "rollback_region0": PASSED
     Test "rollback_region1": PASSED
     Test "rollback_entropy": PASSED
     Test "rtc": PASSED
     Test "sha256": PASSED
     Test "sha256_unrolled": PASSED
     Test "static_if": PASSED
     Test "stdlib": PASSED
     Test "system_is_locked_wp_on": PASSED
     Test "system_is_locked_wp_off": PASSED
     Test "timer_dos": PASSED
     Test "utils": PASSED
     Test "utils_str": PASSED
     Test "stm32f_rtc": PASSED
     Test "panic_data_bloonchipper_v2.0.4277": PASSED
     Test "panic_data_bloonchipper_v2.0.5938": PASSED

Force-Relevant-Builds: all
Signed-off-by: Tom Hughes <tomhughes@chromium.org>
Change-Id: I264ad0ffe7afcd507a1e483c6e934a9c4fea47c3

1 files changed, 641 insertions, 0 deletions

diff --git a/zephyr/test/drivers/default/src/tcs3400.c b/zephyr/test/drivers/default/src/tcs3400.c
new file mode 100644
index 0000000000..860b069532
--- /dev/null
+++ b/zephyr/test/drivers/default/src/tcs3400.c
@@ -0,0 +1,641 @@
+/* Copyright 2021 The ChromiumOS Authors
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <zephyr/kernel.h>
+#include <zephyr/ztest.h>
+
+#include "common.h"
+#include "i2c.h"
+#include "emul/emul_tcs3400.h"
+#include "emul/emul_common_i2c.h"
+
+#include "motion_sense.h"
+#include "motion_sense_fifo.h"
+#include "driver/als_tcs3400.h"
+#include "test/drivers/test_state.h"
+
+#define TCS_NODE DT_NODELABEL(tcs_emul)
+#define TCS_CLR_SENSOR_ID SENSOR_ID(DT_NODELABEL(tcs3400_clear))
+#define TCS_RGB_SENSOR_ID SENSOR_ID(DT_NODELABEL(tcs3400_rgb))
+#define TCS_INT_EVENT \
+	TASK_EVENT_MOTION_SENSOR_INTERRUPT(SENSOR_ID(DT_ALIAS(tcs3400_int)))
+
+/** How accurate comparision of rgb sensors should be */
+#define V_EPS 8
+
+/** Test initialization of light sensor driver and device */
+ZTEST_USER(tcs3400, test_tcs_init)
+{
+	struct motion_sensor_t *ms, *ms_rgb;
+	const struct emul *emul = EMUL_DT_GET(TCS_NODE);
+	struct i2c_common_emul_data *common_data =
+		emul_tcs3400_get_i2c_common_data(emul);
+
+	ms = &motion_sensors[TCS_CLR_SENSOR_ID];
+	ms_rgb = &motion_sensors[TCS_RGB_SENSOR_ID];
+
+	/* RGB sensor initialization is always successful */
+	zassert_equal(EC_SUCCESS, ms_rgb->drv->init(ms_rgb), NULL);
+
+	/* Fail init on communication errors */
+	i2c_common_emul_set_read_fail_reg(common_data,
+					  I2C_COMMON_EMUL_FAIL_ALL_REG);
+	zassert_equal(EC_ERROR_INVAL, ms->drv->init(ms), NULL);
+	i2c_common_emul_set_read_fail_reg(common_data,
+					  I2C_COMMON_EMUL_NO_FAIL_REG);
+
+	/* Fail on bad ID */
+	tcs_emul_set_reg(emul, TCS_I2C_ID, 0);
+	zassert_equal(EC_ERROR_ACCESS_DENIED, ms->drv->init(ms), NULL);
+	/* Restore ID */
+	tcs_emul_set_reg(emul, TCS_I2C_ID,
+			 DT_STRING_TOKEN(DT_NODELABEL(tcs_emul), device_id));
+
+	/* Test successful init. ATIME and AGAIN should be changed on init */
+	zassert_equal(EC_SUCCESS, ms->drv->init(ms), NULL);
+	zassert_equal(TCS_DEFAULT_ATIME, tcs_emul_get_reg(emul, TCS_I2C_ATIME),
+		      NULL);
+	zassert_equal(TCS_DEFAULT_AGAIN,
+		      tcs_emul_get_reg(emul, TCS_I2C_CONTROL), NULL);
+}
+
+/** Test if read function leaves device in correct mode to accuire data */
+ZTEST_USER(tcs3400, test_tcs_read)
+{
+	struct motion_sensor_t *ms;
+	const struct emul *emul = EMUL_DT_GET(TCS_NODE);
+	struct i2c_common_emul_data *common_data =
+		emul_tcs3400_get_i2c_common_data(emul);
+	uint8_t enable;
+	intv3_t v;
+
+	ms = &motion_sensors[TCS_CLR_SENSOR_ID];
+
+	/* Test error on writing registers */
+	i2c_common_emul_set_write_fail_reg(common_data, TCS_I2C_ATIME);
+	zassert_equal(EC_ERROR_INVAL, ms->drv->read(ms, v), NULL);
+	i2c_common_emul_set_write_fail_reg(common_data, TCS_I2C_CONTROL);
+	zassert_equal(EC_ERROR_INVAL, ms->drv->read(ms, v), NULL);
+	i2c_common_emul_set_write_fail_reg(common_data, TCS_I2C_ENABLE);
+	zassert_equal(EC_ERROR_INVAL, ms->drv->read(ms, v), NULL);
+	i2c_common_emul_set_write_fail_reg(common_data,
+					   I2C_COMMON_EMUL_NO_FAIL_REG);
+
+	/* Test starting read with calibration */
+	tcs_emul_set_reg(emul, TCS_I2C_ATIME, 0);
+	tcs_emul_set_reg(emul, TCS_I2C_CONTROL, 0);
+	tcs_emul_set_reg(emul, TCS_I2C_ENABLE, 0);
+	zassert_equal(EC_SUCCESS, ms->drv->perform_calib(ms, 1), NULL);
+	zassert_equal(EC_RES_IN_PROGRESS, ms->drv->read(ms, v), NULL);
+	zassert_equal(TCS_CALIBRATION_ATIME,
+		      tcs_emul_get_reg(emul, TCS_I2C_ATIME), NULL);
+	zassert_equal(TCS_CALIBRATION_AGAIN,
+		      tcs_emul_get_reg(emul, TCS_I2C_CONTROL), NULL);
+	enable = tcs_emul_get_reg(emul, TCS_I2C_ENABLE);
+	zassert_true(enable & TCS_I2C_ENABLE_POWER_ON, NULL);
+	zassert_true(enable & TCS_I2C_ENABLE_ADC_ENABLE, NULL);
+	zassert_true(enable & TCS_I2C_ENABLE_INT_ENABLE, NULL);
+
+	/* Test starting read without calibration */
+	tcs_emul_set_reg(emul, TCS_I2C_ATIME, 0);
+	tcs_emul_set_reg(emul, TCS_I2C_CONTROL, 0);
+	tcs_emul_set_reg(emul, TCS_I2C_ENABLE, 0);
+	zassert_equal(EC_SUCCESS, ms->drv->perform_calib(ms, 0), NULL);
+	zassert_equal(EC_RES_IN_PROGRESS, ms->drv->read(ms, v), NULL);
+	enable = tcs_emul_get_reg(emul, TCS_I2C_ENABLE);
+	zassert_true(enable & TCS_I2C_ENABLE_POWER_ON, NULL);
+	zassert_true(enable & TCS_I2C_ENABLE_ADC_ENABLE, NULL);
+	zassert_true(enable & TCS_I2C_ENABLE_INT_ENABLE, NULL);
+}
+
+/** Check if FIFO for RGB and clear sensor is empty */
+static void check_fifo_empty_f(struct motion_sensor_t *ms,
+			       struct motion_sensor_t *ms_rgb, int line)
+{
+	struct ec_response_motion_sensor_data vector;
+	uint16_t size;
+
+	/* Read all data committed to FIFO */
+	while (motion_sense_fifo_read(sizeof(vector), 1, &vector, &size)) {
+		/* Ignore timestamp frames */
+		if (vector.flags == MOTIONSENSE_SENSOR_FLAG_TIMESTAMP) {
+			continue;
+		}
+
+		if (ms - motion_sensors == vector.sensor_num) {
+			zassert_unreachable(
+				"Unexpected frame for clear sensor @line: %d",
+				line);
+		}
+
+		if (ms_rgb - motion_sensors == vector.sensor_num) {
+			zassert_unreachable(
+				"Unexpected frame for rgb sensor @line: %d",
+				line);
+		}
+	}
+}
+#define check_fifo_empty(ms, ms_rgb) check_fifo_empty_f(ms, ms_rgb, __LINE__)
+
+/**
+ * Test different conditions where irq handler fail or commit no data
+ * to fifo
+ */
+ZTEST_USER(tcs3400, test_tcs_irq_handler_fail)
+{
+	struct motion_sensor_t *ms, *ms_rgb;
+	const struct emul *emul = EMUL_DT_GET(TCS_NODE);
+	struct i2c_common_emul_data *common_data =
+		emul_tcs3400_get_i2c_common_data(emul);
+	uint32_t event;
+
+	ms = &motion_sensors[TCS_CLR_SENSOR_ID];
+	ms_rgb = &motion_sensors[TCS_RGB_SENSOR_ID];
+
+	/* Fail on wrong event */
+	event = 0x1234 & ~TCS_INT_EVENT;
+	zassert_equal(EC_ERROR_NOT_HANDLED, ms->drv->irq_handler(ms, &event),
+		      NULL);
+	check_fifo_empty(ms, ms_rgb);
+
+	event = TCS_INT_EVENT;
+	/* Test error on reading status */
+	i2c_common_emul_set_read_fail_reg(common_data, TCS_I2C_STATUS);
+	zassert_equal(EC_ERROR_INVAL, ms->drv->irq_handler(ms, &event), NULL);
+	i2c_common_emul_set_read_fail_reg(common_data,
+					  I2C_COMMON_EMUL_NO_FAIL_REG);
+	check_fifo_empty(ms, ms_rgb);
+
+	/* Test fail on changing device power state */
+	i2c_common_emul_set_write_fail_reg(common_data, TCS_I2C_ENABLE);
+	zassert_equal(EC_ERROR_INVAL, ms->drv->irq_handler(ms, &event), NULL);
+	i2c_common_emul_set_write_fail_reg(common_data,
+					   I2C_COMMON_EMUL_NO_FAIL_REG);
+	check_fifo_empty(ms, ms_rgb);
+
+	/* Test that no data is committed when status is 0 */
+	tcs_emul_set_reg(emul, TCS_I2C_STATUS, 0);
+	zassert_equal(EC_SUCCESS, ms->drv->irq_handler(ms, &event), NULL);
+	check_fifo_empty(ms, ms_rgb);
+}
+
+/**
+ * Check if last data committed to FIFO for RGB and clear sensor equals to
+ * expected value.
+ */
+static void check_fifo_f(struct motion_sensor_t *ms,
+			 struct motion_sensor_t *ms_rgb, int *exp_v, int eps,
+			 int line)
+{
+	struct ec_response_motion_sensor_data vector;
+	uint16_t size;
+	int ret_v[4] = { -1, -1, -1, -1 };
+	int i;
+
+	/* Read all data committed to FIFO */
+	while (motion_sense_fifo_read(sizeof(vector), 1, &vector, &size)) {
+		/* Ignore timestamp frames */
+		if (vector.flags == MOTIONSENSE_SENSOR_FLAG_TIMESTAMP) {
+			continue;
+		}
+
+		/* Get clear frame */
+		if (ms - motion_sensors == vector.sensor_num) {
+			ret_v[0] = vector.udata[0];
+		}
+
+		/* Get rgb frame */
+		if (ms_rgb - motion_sensors == vector.sensor_num) {
+			ret_v[1] = vector.udata[0];
+			ret_v[2] = vector.udata[1];
+			ret_v[3] = vector.udata[2];
+		}
+	}
+
+	if (ret_v[0] == -1) {
+		zassert_unreachable("No frame for clear sensor, line %d", line);
+	}
+
+	if (ret_v[1] == -1) {
+		zassert_unreachable("No frame for rgb sensor, line %d", line);
+	}
+
+	/* Compare with last committed data */
+	for (i = 0; i < 4; i++) {
+		zassert_within(
+			exp_v[i], ret_v[i], eps,
+			"Expected [%d; %d; %d; %d], got [%d; %d; %d; %d]; line: %d",
+			exp_v[0], exp_v[1], exp_v[2], exp_v[3], ret_v[0],
+			ret_v[1], ret_v[2], ret_v[3], line);
+	}
+}
+#define check_fifo(ms, ms_rgb, exp_v, eps) \
+	check_fifo_f(ms, ms_rgb, exp_v, eps, __LINE__)
+
+/** Test calibration mode reading of light sensor values */
+ZTEST_USER(tcs3400, test_tcs_read_calibration)
+{
+	struct motion_sensor_t *ms, *ms_rgb;
+	const struct emul *emul = EMUL_DT_GET(TCS_NODE);
+	uint32_t event = TCS_INT_EVENT;
+	int emul_v[4];
+	int exp_v[4];
+	intv3_t v;
+
+	ms = &motion_sensors[TCS_CLR_SENSOR_ID];
+	ms_rgb = &motion_sensors[TCS_RGB_SENSOR_ID];
+
+	/* Need to be set to collect all data in FIFO */
+	ms->oversampling_ratio = 1;
+	ms_rgb->oversampling_ratio = 1;
+	/* Enable calibration mode */
+	zassert_equal(EC_SUCCESS, ms->drv->perform_calib(ms, 1), NULL);
+	/* Setup AGAIN and ATIME for calibration */
+	zassert_equal(EC_RES_IN_PROGRESS, ms->drv->read(ms, v), NULL);
+
+	/* Test data that are in calibration range */
+	exp_v[0] = 12;
+	exp_v[1] = 123;
+	exp_v[2] = 1234;
+	exp_v[3] = 12345;
+	/*
+	 * Emulator value is with gain 64, while expected value is
+	 * with gain 16
+	 */
+	emul_v[0] = exp_v[0] * 64 / 16;
+	emul_v[1] = exp_v[1] * 64 / 16;
+	emul_v[2] = exp_v[2] * 64 / 16;
+	emul_v[3] = exp_v[3] * 64 / 16;
+	tcs_emul_set_val(emul, TCS_EMUL_C, emul_v[0]);
+	tcs_emul_set_val(emul, TCS_EMUL_R, emul_v[1]);
+	tcs_emul_set_val(emul, TCS_EMUL_G, emul_v[2]);
+	tcs_emul_set_val(emul, TCS_EMUL_B, emul_v[3]);
+	/* Set status to show valid data */
+	tcs_emul_set_reg(emul, TCS_I2C_STATUS, TCS_I2C_STATUS_RGBC_VALID);
+
+	zassert_equal(EC_SUCCESS, ms->drv->irq_handler(ms, &event), NULL);
+	/* In calibration mode check for exact match */
+	check_fifo(ms, ms_rgb, exp_v, 1);
+
+	/* Test data that are outside of calibration range */
+	exp_v[0] = 0;
+	exp_v[1] = UINT16_MAX;
+	exp_v[2] = UINT16_MAX;
+	exp_v[3] = 213;
+	/*
+	 * Emulator value is with gain 64, while expected value is
+	 * with gain 16
+	 */
+	emul_v[0] = 0;
+	emul_v[1] = exp_v[1] * 64 / 16;
+	emul_v[2] = (UINT16_MAX + 23) * 64 / 16;
+	emul_v[3] = exp_v[3] * 64 / 16;
+	tcs_emul_set_val(emul, TCS_EMUL_C, emul_v[0]);
+	tcs_emul_set_val(emul, TCS_EMUL_R, emul_v[1]);
+	tcs_emul_set_val(emul, TCS_EMUL_G, emul_v[2]);
+	tcs_emul_set_val(emul, TCS_EMUL_B, emul_v[3]);
+	/* Set status to show valid data */
+	tcs_emul_set_reg(emul, TCS_I2C_STATUS, TCS_I2C_STATUS_RGBC_VALID);
+
+	zassert_equal(EC_SUCCESS, ms->drv->irq_handler(ms, &event), NULL);
+	/* In calibration mode check for exact match */
+	check_fifo(ms, ms_rgb, exp_v, 1);
+}
+
+/**
+ * Set emulator internal value using expected output value returned by
+ * the driver. First element of expected vector is IR value used in
+ * calculations. Based on that clear light value is calculated.
+ * First element of expected vector is updated by this function.
+ */
+static void set_emul_val_from_exp(int *exp_v, uint16_t *scale,
+				  const struct emul *emul)
+{
+	int emul_v[4];
+	int ir;
+
+	/* We use exp_v[0] as IR value */
+	ir = exp_v[0];
+	/* Driver will return lux value as calculated blue light value */
+	exp_v[0] = exp_v[2];
+
+	/*
+	 * Driver takes care of different ATIME and AGAIN value, so expected
+	 * value is always normalized to ATIME 256 and AGAIN 16. Convert it
+	 * to internal emulator value (ATIME 256, AGAIN 64) and add expected IR
+	 * value. Clear light is the sum of rgb light and IR component.
+	 */
+	emul_v[1] = (exp_v[1] + ir) * 64 / 16;
+	emul_v[2] = (exp_v[2] + ir) * 64 / 16;
+	emul_v[3] = (exp_v[3] + ir) * 64 / 16;
+	emul_v[0] = (exp_v[1] + exp_v[2] + exp_v[3] + ir) * 64 / 16;
+
+	/* Apply scale, driver should divide by this value */
+	emul_v[0] = SENSOR_APPLY_SCALE(emul_v[0], scale[0]);
+	emul_v[1] = SENSOR_APPLY_SCALE(emul_v[1], scale[1]);
+	emul_v[2] = SENSOR_APPLY_SCALE(emul_v[2], scale[2]);
+	emul_v[3] = SENSOR_APPLY_SCALE(emul_v[3], scale[3]);
+
+	/* Set emulator values */
+	tcs_emul_set_val(emul, TCS_EMUL_C, emul_v[0]);
+	tcs_emul_set_val(emul, TCS_EMUL_R, emul_v[1]);
+	tcs_emul_set_val(emul, TCS_EMUL_G, emul_v[2]);
+	tcs_emul_set_val(emul, TCS_EMUL_B, emul_v[3]);
+}
+
+/** Test normal mode reading of light sensor values */
+ZTEST_USER(tcs3400, test_tcs_read_xyz)
+{
+	struct motion_sensor_t *ms, *ms_rgb;
+	const struct emul *emul = EMUL_DT_GET(TCS_NODE);
+	uint32_t event = TCS_INT_EVENT;
+	/* Expected data to test: IR, R, G, B */
+	int exp_v[][4] = {
+		{ 200, 1110, 870, 850 },       { 300, 1110, 10000, 8500 },
+		{ 600, 50000, 40000, 30000 },  { 1000, 3000, 40000, 2000 },
+		{ 1000, 65000, 65000, 65000 }, { 100, 214, 541, 516 },
+		{ 143, 2141, 5414, 5163 },     { 100, 50000, 40000, 30000 },
+		{ 1430, 2141, 5414, 5163 },    { 10000, 50000, 40000, 30000 },
+		{ 10000, 214, 541, 516 },      { 15000, 50000, 40000, 30000 },
+	};
+	uint16_t scale[4] = { MOTION_SENSE_DEFAULT_SCALE,
+			      MOTION_SENSE_DEFAULT_SCALE,
+			      MOTION_SENSE_DEFAULT_SCALE,
+			      MOTION_SENSE_DEFAULT_SCALE };
+	int i, test;
+	intv3_t v;
+
+	ms = &motion_sensors[TCS_CLR_SENSOR_ID];
+	ms_rgb = &motion_sensors[TCS_RGB_SENSOR_ID];
+
+	/* Need to be set to collect all data in FIFO */
+	ms->oversampling_ratio = 1;
+	ms_rgb->oversampling_ratio = 1;
+	/* Disable calibration mode */
+	zassert_equal(EC_SUCCESS, ms->drv->perform_calib(ms, 0), NULL);
+	/* Setup AGAIN and ATIME for normal mode */
+	zassert_equal(EC_RES_IN_PROGRESS, ms->drv->read(ms, v), NULL);
+
+	/* Test different data in supported range */
+	for (test = 0; test < ARRAY_SIZE(exp_v); test++) {
+		set_emul_val_from_exp(exp_v[test], scale, emul);
+
+		/* Run few times to allow driver change gain */
+		for (i = 0; i < 5; i++) {
+			tcs_emul_set_reg(emul, TCS_I2C_STATUS,
+					 TCS_I2C_STATUS_RGBC_VALID);
+			zassert_equal(EC_SUCCESS,
+				      ms->drv->irq_handler(ms, &event), NULL);
+		}
+		check_fifo(ms, ms_rgb, exp_v[test], V_EPS);
+	}
+
+	/* Test data that are outside of supported range */
+	exp_v[0][0] = 3000;
+	exp_v[0][1] = UINT16_MAX;
+	exp_v[0][2] = UINT16_MAX * 32;
+	exp_v[0][3] = 200;
+	set_emul_val_from_exp(exp_v[0], scale, emul);
+
+	/* Run few times to allow driver change gain */
+	for (i = 0; i < 10; i++) {
+		tcs_emul_set_reg(emul, TCS_I2C_STATUS,
+				 TCS_I2C_STATUS_RGBC_VALID);
+		zassert_equal(EC_SUCCESS, ms->drv->irq_handler(ms, &event),
+			      NULL);
+	}
+	/*
+	 * If saturation value is exceeded on any rgb sensor, than data
+	 * shouldn't be committed to FIFO.
+	 */
+	check_fifo_empty(ms, ms_rgb);
+}
+
+/**
+ * Test getting and setting scale of light sensor. Checks if collected values
+ * are scaled properly.
+ */
+ZTEST_USER(tcs3400, test_tcs_scale)
+{
+	struct motion_sensor_t *ms, *ms_rgb;
+	const struct emul *emul = EMUL_DT_GET(TCS_NODE);
+	uint32_t event = TCS_INT_EVENT;
+	/* Expected data to test: IR, R, G, B */
+	int exp_v[][4] = {
+		{ 200, 1110, 870, 850 },   { 300, 1110, 10000, 8500 },
+		{ 600, 5000, 4000, 3000 }, { 100, 3000, 4000, 2000 },
+		{ 100, 1000, 1000, 1000 },
+	};
+	/* Scale for each test */
+	uint16_t exp_scale[][4] = {
+		{ MOTION_SENSE_DEFAULT_SCALE, MOTION_SENSE_DEFAULT_SCALE,
+		  MOTION_SENSE_DEFAULT_SCALE, MOTION_SENSE_DEFAULT_SCALE },
+		{ MOTION_SENSE_DEFAULT_SCALE + 300,
+		  MOTION_SENSE_DEFAULT_SCALE + 300,
+		  MOTION_SENSE_DEFAULT_SCALE + 300,
+		  MOTION_SENSE_DEFAULT_SCALE + 300 },
+		{ MOTION_SENSE_DEFAULT_SCALE - 300,
+		  MOTION_SENSE_DEFAULT_SCALE - 300,
+		  MOTION_SENSE_DEFAULT_SCALE - 300,
+		  MOTION_SENSE_DEFAULT_SCALE - 300 },
+		{ MOTION_SENSE_DEFAULT_SCALE + 345,
+		  MOTION_SENSE_DEFAULT_SCALE - 5423,
+		  MOTION_SENSE_DEFAULT_SCALE - 30,
+		  MOTION_SENSE_DEFAULT_SCALE + 400 },
+		{ MOTION_SENSE_DEFAULT_SCALE - 345,
+		  MOTION_SENSE_DEFAULT_SCALE + 5423,
+		  MOTION_SENSE_DEFAULT_SCALE + 30,
+		  MOTION_SENSE_DEFAULT_SCALE - 400 },
+		{ MOTION_SENSE_DEFAULT_SCALE, MOTION_SENSE_DEFAULT_SCALE,
+		  MOTION_SENSE_DEFAULT_SCALE, MOTION_SENSE_DEFAULT_SCALE }
+	};
+	uint16_t scale[3];
+	int16_t temp;
+	int i, test;
+	intv3_t v;
+
+	ms = &motion_sensors[TCS_CLR_SENSOR_ID];
+	ms_rgb = &motion_sensors[TCS_RGB_SENSOR_ID];
+
+	/* Need to be set to collect all data in FIFO */
+	ms->oversampling_ratio = 1;
+	ms_rgb->oversampling_ratio = 1;
+	/* Disable calibration mode */
+	zassert_equal(EC_SUCCESS, ms->drv->perform_calib(ms, 0), NULL);
+	/* Setup AGAIN and ATIME for normal mode */
+	zassert_equal(EC_RES_IN_PROGRESS, ms->drv->read(ms, v), NULL);
+
+	/* Test different data in supported range */
+	for (test = 0; test < ARRAY_SIZE(exp_v); test++) {
+		/* Set and test clear sensor scale */
+		zassert_equal(EC_SUCCESS,
+			      ms->drv->set_scale(ms, exp_scale[test], 0),
+			      "test %d", test);
+		zassert_equal(EC_SUCCESS, ms->drv->get_scale(ms, scale, &temp),
+			      "test %d", test);
+		zassert_equal((int16_t)EC_MOTION_SENSE_INVALID_CALIB_TEMP, temp,
+			      "test %d, %d", test, temp);
+		zassert_equal(exp_scale[test][0], scale[0], "test %d", test);
+
+		/* Set and test RGB sensor scale */
+		zassert_equal(EC_SUCCESS,
+			      ms_rgb->drv->set_scale(ms_rgb,
+						     &(exp_scale[test][1]), 0),
+			      "test %d", test);
+		zassert_equal(EC_SUCCESS,
+			      ms_rgb->drv->get_scale(ms_rgb, scale, &temp),
+			      "test %d", test);
+		zassert_equal((int16_t)EC_MOTION_SENSE_INVALID_CALIB_TEMP, temp,
+			      "test %d", test);
+		zassert_equal(exp_scale[test][1], scale[0], "test %d", test);
+		zassert_equal(exp_scale[test][2], scale[1], "test %d", test);
+		zassert_equal(exp_scale[test][3], scale[2], "test %d", test);
+
+		set_emul_val_from_exp(exp_v[test], exp_scale[test], emul);
+
+		/* Run few times to allow driver change gain */
+		for (i = 0; i < 5; i++) {
+			tcs_emul_set_reg(emul, TCS_I2C_STATUS,
+					 TCS_I2C_STATUS_RGBC_VALID);
+			zassert_equal(EC_SUCCESS,
+				      ms->drv->irq_handler(ms, &event), NULL);
+		}
+		check_fifo(ms, ms_rgb, exp_v[test], V_EPS);
+	}
+
+	/* Test fail if scale equals 0 */
+	scale[0] = 0;
+	scale[1] = MOTION_SENSE_DEFAULT_SCALE;
+	scale[2] = MOTION_SENSE_DEFAULT_SCALE;
+	zassert_equal(EC_ERROR_INVAL, ms->drv->set_scale(ms, scale, 0), NULL);
+
+	zassert_equal(EC_ERROR_INVAL, ms_rgb->drv->set_scale(ms_rgb, scale, 0),
+		      NULL);
+	scale[0] = MOTION_SENSE_DEFAULT_SCALE;
+	scale[1] = 0;
+	scale[2] = MOTION_SENSE_DEFAULT_SCALE;
+	zassert_equal(EC_ERROR_INVAL, ms_rgb->drv->set_scale(ms_rgb, scale, 0),
+		      NULL);
+	scale[0] = MOTION_SENSE_DEFAULT_SCALE;
+	scale[1] = MOTION_SENSE_DEFAULT_SCALE;
+	scale[2] = 0;
+	zassert_equal(EC_ERROR_INVAL, ms_rgb->drv->set_scale(ms_rgb, scale, 0),
+		      NULL);
+}
+
+/** Test setting and getting data rate of light sensor */
+ZTEST_USER(tcs3400, test_tcs_data_rate)
+{
+	struct motion_sensor_t *ms, *ms_rgb;
+	const struct emul *emul = EMUL_DT_GET(TCS_NODE);
+	struct i2c_common_emul_data *common_data =
+		emul_tcs3400_get_i2c_common_data(emul);
+	uint8_t enable;
+
+	ms = &motion_sensors[TCS_CLR_SENSOR_ID];
+	/* RGB sensor doesn't set rate, but return rate of clear sesnor */
+	ms_rgb = &motion_sensors[TCS_RGB_SENSOR_ID];
+
+	/* Test fail on reading device power state */
+	i2c_common_emul_set_read_fail_reg(common_data, TCS_I2C_ENABLE);
+	zassert_equal(EC_ERROR_INVAL, ms->drv->set_data_rate(ms, 0, 0), NULL);
+	zassert_equal(EC_ERROR_INVAL, ms->drv->set_data_rate(ms, 0, 1), NULL);
+	zassert_equal(EC_ERROR_INVAL, ms->drv->set_data_rate(ms, 100, 0), NULL);
+	zassert_equal(EC_ERROR_INVAL, ms->drv->set_data_rate(ms, 100, 1), NULL);
+	i2c_common_emul_set_read_fail_reg(common_data,
+					  I2C_COMMON_EMUL_NO_FAIL_REG);
+
+	/* Test setting 0 rate disables device */
+	zassert_equal(EC_SUCCESS, ms->drv->set_data_rate(ms, 0, 0), NULL);
+	zassert_equal(0, tcs_emul_get_reg(emul, TCS_I2C_ENABLE), NULL);
+	zassert_equal(0, ms->drv->get_data_rate(ms), NULL);
+	zassert_equal(0, ms_rgb->drv->get_data_rate(ms_rgb), NULL);
+
+	zassert_equal(EC_SUCCESS, ms->drv->set_data_rate(ms, 0, 1), NULL);
+	zassert_equal(0, tcs_emul_get_reg(emul, TCS_I2C_ENABLE), NULL);
+	zassert_equal(0, tcs_emul_get_reg(emul, TCS_I2C_ENABLE), NULL);
+	zassert_equal(0, ms->drv->get_data_rate(ms), NULL);
+	zassert_equal(0, ms_rgb->drv->get_data_rate(ms_rgb), NULL);
+
+	/* Test setting non-zero rate enables device */
+	zassert_equal(EC_SUCCESS, ms->drv->set_data_rate(ms, 100, 0), NULL);
+	enable = tcs_emul_get_reg(emul, TCS_I2C_ENABLE);
+	zassert_true(enable & TCS_I2C_ENABLE_POWER_ON, NULL);
+	zassert_true(enable & TCS_I2C_ENABLE_ADC_ENABLE, NULL);
+	zassert_true(enable & TCS_I2C_ENABLE_INT_ENABLE, NULL);
+	zassert_equal(100, ms->drv->get_data_rate(ms), NULL);
+	zassert_equal(100, ms_rgb->drv->get_data_rate(ms_rgb), NULL);
+
+	zassert_equal(EC_SUCCESS, ms->drv->set_data_rate(ms, 100, 1), NULL);
+	enable = tcs_emul_get_reg(emul, TCS_I2C_ENABLE);
+	zassert_true(enable & TCS_I2C_ENABLE_POWER_ON, NULL);
+	zassert_true(enable & TCS_I2C_ENABLE_ADC_ENABLE, NULL);
+	zassert_true(enable & TCS_I2C_ENABLE_INT_ENABLE, NULL);
+	zassert_equal(100, ms->drv->get_data_rate(ms), NULL);
+	zassert_equal(100, ms_rgb->drv->get_data_rate(ms_rgb), NULL);
+
+	/* Test RGB sensor doesn't change data rate */
+	zassert_equal(EC_SUCCESS, ms_rgb->drv->set_data_rate(ms_rgb, 300, 0),
+		      NULL);
+	zassert_equal(100, ms->drv->get_data_rate(ms), NULL);
+	zassert_equal(100, ms_rgb->drv->get_data_rate(ms_rgb), NULL);
+
+	zassert_equal(EC_SUCCESS, ms_rgb->drv->set_data_rate(ms_rgb, 300, 1),
+		      NULL);
+	zassert_equal(100, ms->drv->get_data_rate(ms), NULL);
+	zassert_equal(100, ms_rgb->drv->get_data_rate(ms_rgb), NULL);
+}
+
+/** Test set range function of clear and RGB sensors */
+ZTEST_USER(tcs3400, test_tcs_set_range)
+{
+	struct motion_sensor_t *ms, *ms_rgb;
+
+	ms = &motion_sensors[TCS_CLR_SENSOR_ID];
+	ms_rgb = &motion_sensors[TCS_RGB_SENSOR_ID];
+
+	/* RGB sensor doesn't set anything */
+	zassert_equal(EC_SUCCESS, ms_rgb->drv->set_range(ms_rgb, 1, 0), NULL);
+
+	/* Clear sensor doesn't change anything on device to set range */
+	zassert_equal(EC_SUCCESS, ms->drv->set_range(ms, 0x12300, 1), NULL);
+	zassert_equal(0x12300, ms->current_range, NULL);
+
+	zassert_equal(EC_SUCCESS, ms->drv->set_range(ms, 0x10000, 0), NULL);
+	zassert_equal(0x10000, ms->current_range, NULL);
+}
+
+struct tcs3400_test_fixture {
+	struct als_drv_data_t drv_data;
+	struct tcs3400_rgb_drv_data_t rgb_drv_data;
+};
+
+static void tcs3400_before(void *state)
+{
+	struct tcs3400_test_fixture *f = state;
+
+	f->drv_data = *TCS3400_DRV_DATA(&motion_sensors[TCS_CLR_SENSOR_ID]);
+	f->rgb_drv_data =
+		*TCS3400_RGB_DRV_DATA(&motion_sensors[TCS_RGB_SENSOR_ID]);
+}
+
+static void tcs3400_after(void *state)
+{
+	struct tcs3400_test_fixture *f = state;
+
+	*TCS3400_DRV_DATA(&motion_sensors[TCS_CLR_SENSOR_ID]) = f->drv_data;
+	*TCS3400_RGB_DRV_DATA(&motion_sensors[TCS_RGB_SENSOR_ID]) =
+		f->rgb_drv_data;
+}
+
+static void *tcs3400_setup(void)
+{
+	static struct tcs3400_test_fixture tcs3400_fixture = { 0 };
+
+	return &tcs3400_fixture;
+}
+
+ZTEST_SUITE(tcs3400, drivers_predicate_post_main, tcs3400_setup, tcs3400_before,
+	    tcs3400_after, NULL);