tests/drivers/can/timing/src/main.c

/*
 * Copyright (c) 2022-2024 Vestas Wind Systems A/S
 * Copyright (c) 2019 Alexander Wachter
 *
 * SPDX-License-Identifier: Apache-2.0
 */

#include <zephyr/drivers/can.h>
#include <zephyr/ztest.h>
#include <strings.h>

/**
 * @addtogroup t_driver_can
 * @{
 * @defgroup t_can_timing test_can_timing
 * @}
 */

/**
 * @brief Allowed sample point calculation margin in permille.
 */
#define SAMPLE_POINT_MARGIN 50

/**
 * @brief Defines a set of CAN timing test values
 */
struct can_timing_test {
	/** Bitrate in bit/s */
	uint32_t bitrate;
	/** Desired sample point in permille */
	uint16_t sp;
};

/**
 * @brief List of CAN timing values to test.
 */
static const struct can_timing_test can_timing_tests[] = {
	/* CiA 301 recommended bitrates */
#ifdef CONFIG_TEST_ALL_BITRATES
	{   10000, 875 },
#endif /* CONFIG_TEST_ALL_BITRATES */
	{   20000, 875 },
	{   50000, 875 },
	{  125000, 875 },
	{  250000, 875 },
	{  500000, 875 },
	{  800000, 800 },
	{ 1000000, 750 },
};

/**
 * @brief List of CAN FD data phase timing values to test.
 */
static const struct can_timing_test can_timing_data_tests[] = {
	/* CiA 601-2 recommended data phase bitrates */
	{ 1000000, 750 },
#ifdef CONFIG_TEST_ALL_BITRATES
	{ 2000000, 750 },
	{ 4000000, 750 },
	{ 5000000, 750 },
	{ 8000000, 750 },
#endif /* CONFIG_TEST_ALL_BITRATES */
};

/**
 * @brief Assert that a CAN timing struct matches the specified bitrate
 *
 * Assert that the values of a CAN timing struct matches the specified bitrate
 * for a given CAN controller device instance.
 *
 * @param dev pointer to the device structure for the driver instance
 * @param timing pointer to the CAN timing struct
 * @param bitrate the CAN bitrate in bit/s
 */
static void assert_bitrate_correct(const struct device *dev, struct can_timing *timing,
				   uint32_t bitrate)
{
	const uint32_t ts = 1 + timing->prop_seg + timing->phase_seg1 + timing->phase_seg2;
	uint32_t core_clock;
	uint32_t bitrate_calc;
	int err;

	zassert_not_equal(timing->prescaler, 0, "prescaler is zero");

	err = can_get_core_clock(dev, &core_clock);
	zassert_equal(err, 0, "failed to get core CAN clock");

	bitrate_calc = core_clock / timing->prescaler / ts;
	zassert_equal(bitrate, bitrate_calc, "bitrate mismatch");
}

/**
 * @brief Assert that a CAN timing struct is within the bounds
 *
 * Assert that the values of a CAN timing struct are within the bounds for a
 * given CAN controller device instance.
 *
 * @param dev pointer to the device structure for the driver instance
 * @param timing pointer to the CAN timing struct
 */
static void assert_timing_within_bounds(struct can_timing *timing,
					const struct can_timing *min,
					const struct can_timing *max)
{
	zassert_true(timing->sjw <= max->sjw, "sjw exceeds max");
	zassert_true(timing->prop_seg <= max->prop_seg, "prop_seg exceeds max");
	zassert_true(timing->phase_seg1 <= max->phase_seg1, "phase_seg1 exceeds max");
	zassert_true(timing->phase_seg2 <= max->phase_seg2, "phase_seg2 exceeds max");
	zassert_true(timing->prescaler <= max->prescaler, "prescaler exceeds max");

	zassert_true(timing->sjw >= min->sjw, "sjw lower than min");
	zassert_true(timing->prop_seg >= min->prop_seg, "prop_seg lower than min");
	zassert_true(timing->phase_seg1 >= min->phase_seg1, "phase_seg1 lower than min");
	zassert_true(timing->phase_seg2 >= min->phase_seg2, "phase_seg2 lower than min");
	zassert_true(timing->prescaler >= min->prescaler, "prescaler lower than min");
}

/**
 * @brief Assert that a sample point is within a specified margin
 *
 * Assert that values of a CAN timing struct results in a specified sample point
 * within a given margin.
 *
 * @param timing pointer to the CAN timing struct
 * @param sp sample point in permille
 * @param sp_margin sample point margin in permille
 */
static void assert_sp_within_margin(struct can_timing *timing, uint16_t sp, uint16_t sp_margin)
{
	const uint32_t ts = 1 + timing->prop_seg + timing->phase_seg1 + timing->phase_seg2;
	const uint16_t sp_calc = ((1 + timing->prop_seg + timing->phase_seg1) * 1000) / ts;

	zassert_within(sp, sp_calc, sp_margin,
		       "sample point %d not within calculated sample point %d +/- %d",
		       sp, sp_calc, sp_margin);
}

/**
 * @brief Test a set of CAN timing values
 *
 * Test a set of CAN timing values on a specified CAN controller device
 * instance.
 *
 * @param  dev pointer to the device structure for the driver instance
 * @param  test pointer to the set of CAN timing values
 * returns true if bitrate was supported, false otherwise
 */
static bool test_timing_values(const struct device *dev, const struct can_timing_test *test,
			       bool data_phase)
{
	const struct can_timing *max = NULL;
	const struct can_timing *min = NULL;
	struct can_timing timing = { 0 };
	int sp_err = -EINVAL;
	int err;

	printk("testing bitrate %u, sample point %u.%u%%: ",
	       test->bitrate, test->sp / 10, test->sp % 10);

	if (data_phase) {
		if (IS_ENABLED(CONFIG_CAN_FD_MODE)) {
			min = can_get_timing_data_min(dev);
			max = can_get_timing_data_max(dev);
			sp_err = can_calc_timing_data(dev, &timing, test->bitrate, test->sp);
		} else {
			zassert_unreachable("data phase timing test without CAN FD support");
		}
	} else {
		min = can_get_timing_min(dev);
		max = can_get_timing_max(dev);
		sp_err = can_calc_timing(dev, &timing, test->bitrate, test->sp);
	}

	if (sp_err == -ENOTSUP) {
		printk("bitrate not supported\n");
		return false;
	} else {
		zassert_true(sp_err >= 0, "unknown error %d", sp_err);
		zassert_true(sp_err <= SAMPLE_POINT_MARGIN, "sample point error %d too large",
			     sp_err);

		printk("sjw = %u, prop_seg = %u, phase_seg1 = %u, phase_seg2 = %u, prescaler = %u ",
			timing.sjw, timing.prop_seg, timing.phase_seg1, timing.phase_seg2,
			timing.prescaler);

		assert_bitrate_correct(dev, &timing, test->bitrate);
		assert_timing_within_bounds(&timing, min, max);
		assert_sp_within_margin(&timing, test->sp, SAMPLE_POINT_MARGIN);

		if (IS_ENABLED(CONFIG_CAN_FD_MODE) && data_phase) {
			err = can_set_timing_data(dev, &timing);
		} else {
			err = can_set_timing(dev, &timing);
		}
		zassert_equal(err, 0, "failed to set timing (err %d)", err);

		printk("OK, sample point error %d.%d%%\n", sp_err / 10, sp_err % 10);
	}

	return true;
}

/**
 * @brief Test all CAN timing values
 */
ZTEST_USER(can_timing, test_timing)
{
	const struct device *const dev = DEVICE_DT_GET(DT_CHOSEN(zephyr_canbus));
	int count = 0;
	int i;

	for (i = 0; i < ARRAY_SIZE(can_timing_tests); i++) {
		if (test_timing_values(dev, &can_timing_tests[i], false)) {
			count++;
		}
	}

	zassert_true(count > 0, "no bitrates supported");
}

/**
 * @brief Test all CAN timing values for the data phase.
 */
ZTEST_USER(can_timing, test_timing_data)
{
	const struct device *const dev = DEVICE_DT_GET(DT_CHOSEN(zephyr_canbus));
	can_mode_t cap;
	int count = 0;
	int err;
	int i;

	err = can_get_capabilities(dev, &cap);
	zassert_equal(err, 0, "failed to get CAN controller capabilities (err %d)", err);

	if ((cap & CAN_MODE_FD) == 0) {
		ztest_test_skip();
	}

	for (i = 0; i < ARRAY_SIZE(can_timing_data_tests); i++) {
		if (test_timing_values(dev, &can_timing_data_tests[i], true)) {
			count++;
		}
	}

	zassert_true(count > 0, "no data phase bitrates supported");
}

void *can_timing_setup(void)
{
	const struct device *const dev = DEVICE_DT_GET(DT_CHOSEN(zephyr_canbus));
	uint32_t core_clock;
	int err;

	zassert_true(device_is_ready(dev), "CAN device not ready");
	k_object_access_grant(dev, k_current_get());

	err = can_get_core_clock(dev, &core_clock);
	zassert_equal(err, 0, "failed to get core CAN clock");

	printk("testing on device %s @ %u Hz\n", dev->name, core_clock);

	if (IS_ENABLED(CONFIG_CAN_FD_MODE)) {
		can_mode_t cap;

		err = can_get_capabilities(dev, &cap);
		zassert_equal(err, 0, "failed to get CAN controller capabilities (err %d)", err);

		if ((cap & CAN_MODE_FD) != 0) {
			switch (core_clock) {
			case MHZ(20):
				break;
			case MHZ(40):
				break;
			case MHZ(80):
				break;
			default:
				TC_PRINT("Warning: CiA 601-3 recommends a CAN FD core clock of "
					"20, 40, or 80 MHz for good node interoperability\n");
				break;
			}
		}
	}

	if (!IS_ENABLED(CONFIG_TEST_ALL_BITRATES)) {
		TC_PRINT("Warning: Testing limited selection of bitrates "
			 "(CONFIG_TEST_ALL_BITRATES=n)\n");
	}

	return NULL;
}

ZTEST_SUITE(can_timing, NULL, can_timing_setup, NULL, NULL, NULL);