diff options
Diffstat (limited to 'zephyr/test/drivers/default/src/ln9310.c')
| -rw-r--r-- | zephyr/test/drivers/default/src/ln9310.c | 685 |
1 files changed, 685 insertions, 0 deletions
diff --git a/zephyr/test/drivers/default/src/ln9310.c b/zephyr/test/drivers/default/src/ln9310.c new file mode 100644 index 0000000000..326e8480ef --- /dev/null +++ b/zephyr/test/drivers/default/src/ln9310.c @@ -0,0 +1,685 @@ +/* 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/ztest.h> +#include <zephyr/drivers/emul.h> +#include <zephyr/kernel.h> +#include <zephyr/ztest_assert.h> +#include <zephyr/drivers/i2c_emul.h> + +#include "driver/ln9310.h" +#include "emul/emul_ln9310.h" +#include "emul/emul_common_i2c.h" +#include "timer.h" +#include "test/drivers/test_state.h" + +/* + * TODO(b/201420132): Implement approach for tests to immediately schedule work + * to avoid any sleeping + */ +#define TEST_DELAY_MS 50 + +#define EMUL_LN9310_NODE DT_NODELABEL(ln9310) + +/* + * Chip revisions below LN9310_BC_STS_C_CHIP_REV_FIXED require an alternative + * software startup to properly initialize and power up. + */ +#define REQUIRES_CFLY_PRECHARGE_STARTUP_CHIP_REV \ + (LN9310_BC_STS_C_CHIP_REV_FIXED - 1) + +ZTEST(ln9310, test_ln9310_read_chip_fails) +{ + const struct emul *emulator = EMUL_DT_GET(EMUL_LN9310_NODE); + struct i2c_common_emul_data *common_data = + emul_ln9310_get_i2c_common_data(emulator); + + zassert_not_null(emulator, NULL); + + ln9310_emul_set_context(emulator); + ln9310_emul_reset(emulator); + /* Battery and chip rev won't matter here so only testing one pair */ + ln9310_emul_set_battery_cell_type(emulator, BATTERY_CELL_TYPE_2S); + ln9310_emul_set_version(emulator, LN9310_BC_STS_C_CHIP_REV_FIXED); + + i2c_common_emul_set_read_fail_reg(common_data, LN9310_REG_BC_STS_C); + + zassert_true(ln9310_init() != 0, NULL); + zassert_false(ln9310_emul_is_init(emulator), NULL); + + /* TODO(b/201420132) */ + k_msleep(TEST_DELAY_MS); + zassert_false(ln9310_power_good(), NULL); + + i2c_common_emul_set_read_fail_reg(common_data, + I2C_COMMON_EMUL_NO_FAIL_REG); +} + +ZTEST(ln9310, test_ln9310_2s_powers_up) +{ + const struct emul *emulator = EMUL_DT_GET(EMUL_LN9310_NODE); + + zassert_not_null(emulator, NULL); + + ln9310_emul_set_context(emulator); + ln9310_emul_reset(emulator); + ln9310_emul_set_battery_cell_type(emulator, BATTERY_CELL_TYPE_2S); + ln9310_emul_set_version(emulator, LN9310_BC_STS_C_CHIP_REV_FIXED); + + zassert_ok(ln9310_init(), NULL); + zassert_true(ln9310_emul_is_init(emulator), NULL); + + /* TODO(b/201420132) */ + k_msleep(TEST_DELAY_MS); + zassert_false(ln9310_power_good(), NULL); + + ln9310_software_enable(true); + + k_msleep(TEST_DELAY_MS); + zassert_true(ln9310_power_good(), NULL); +} + +ZTEST(ln9310, test_ln9310_3s_powers_up) +{ + const struct emul *emulator = EMUL_DT_GET(EMUL_LN9310_NODE); + + zassert_not_null(emulator, NULL); + + ln9310_emul_set_context(emulator); + ln9310_emul_reset(emulator); + ln9310_emul_set_battery_cell_type(emulator, BATTERY_CELL_TYPE_3S); + ln9310_emul_set_version(emulator, LN9310_BC_STS_C_CHIP_REV_FIXED); + + zassert_ok(ln9310_init(), NULL); + zassert_true(ln9310_emul_is_init(emulator), NULL); + + /* TODO(b/201420132) */ + k_msleep(TEST_DELAY_MS); + zassert_false(ln9310_power_good(), NULL); + + ln9310_software_enable(true); + + k_msleep(TEST_DELAY_MS); + zassert_true(ln9310_power_good(), NULL); +} + +struct startup_workaround_data { + bool startup_workaround_attempted; + bool startup_workaround_should_fail; +}; + +static int mock_write_fn_intercept_startup_workaround(const struct emul *emul, + int reg, uint8_t val, + int bytes, void *data) +{ + struct startup_workaround_data *test_data = data; + + uint8_t startup_workaround_val = + (LN9310_TEST_MODE_CTRL_FORCE_SC_OUT_PRECHARGE_ON | + LN9310_TEST_MODE_CTRL_FORCE_SC_OUT_PREDISCHARGE_ON); + + test_data->startup_workaround_attempted = + test_data->startup_workaround_attempted || + ((reg == LN9310_REG_TEST_MODE_CTRL) && + (val == startup_workaround_val)); + + if (test_data->startup_workaround_should_fail) + return -1; + + return 1; +} + +ZTEST(ln9310, test_ln9310_2s_cfly_precharge_startup) +{ + const struct emul *emulator = EMUL_DT_GET(EMUL_LN9310_NODE); + struct i2c_common_emul_data *common_data = + emul_ln9310_get_i2c_common_data(emulator); + + struct startup_workaround_data test_data = { + .startup_workaround_attempted = false, + .startup_workaround_should_fail = false, + }; + + zassert_not_null(emulator, NULL); + + ln9310_emul_set_context(emulator); + ln9310_emul_reset(emulator); + ln9310_emul_set_battery_cell_type(emulator, BATTERY_CELL_TYPE_2S); + ln9310_emul_set_version(emulator, + REQUIRES_CFLY_PRECHARGE_STARTUP_CHIP_REV); + + zassert_ok(ln9310_init(), NULL); + zassert_true(ln9310_emul_is_init(emulator), NULL); + + /* TODO(b/201420132) */ + k_msleep(TEST_DELAY_MS); + zassert_false(ln9310_power_good(), NULL); + + i2c_common_emul_set_write_func( + common_data, mock_write_fn_intercept_startup_workaround, + &test_data); + + ln9310_software_enable(true); + zassert_true(test_data.startup_workaround_attempted, NULL); + + /* TODO(b/201420132) */ + k_msleep(TEST_DELAY_MS); + zassert_true(ln9310_power_good(), NULL); + + ln9310_software_enable(false); + + /* TODO(b/201420132) */ + k_msleep(TEST_DELAY_MS); + zassert_false(ln9310_power_good(), NULL); + + i2c_common_emul_set_write_func(common_data, NULL, NULL); +} + +ZTEST(ln9310, test_ln9310_3s_cfly_precharge_startup) +{ + const struct emul *emulator = EMUL_DT_GET(EMUL_LN9310_NODE); + struct i2c_common_emul_data *common_data = + emul_ln9310_get_i2c_common_data(emulator); + + struct startup_workaround_data test_data = { + .startup_workaround_attempted = false, + .startup_workaround_should_fail = false, + }; + + zassert_not_null(emulator, NULL); + + ln9310_emul_set_context(emulator); + ln9310_emul_reset(emulator); + ln9310_emul_set_battery_cell_type(emulator, BATTERY_CELL_TYPE_3S); + ln9310_emul_set_version(emulator, + REQUIRES_CFLY_PRECHARGE_STARTUP_CHIP_REV); + + zassert_ok(ln9310_init(), NULL); + zassert_true(ln9310_emul_is_init(emulator), NULL); + + /* TODO(b/201420132) */ + k_msleep(TEST_DELAY_MS); + zassert_false(ln9310_power_good(), NULL); + + i2c_common_emul_set_write_func( + common_data, mock_write_fn_intercept_startup_workaround, + &test_data); + + ln9310_software_enable(true); + zassert_true(test_data.startup_workaround_attempted, NULL); + + /* TODO(b/201420132) */ + k_msleep(TEST_DELAY_MS); + zassert_true(ln9310_power_good(), NULL); + + ln9310_software_enable(false); + + /* TODO(b/201420132) */ + k_msleep(TEST_DELAY_MS); + zassert_false(ln9310_power_good(), NULL); + + i2c_common_emul_set_write_func(common_data, NULL, NULL); +} + +ZTEST(ln9310, test_ln9310_cfly_precharge_exceeds_retries) +{ + const struct emul *emulator = EMUL_DT_GET(EMUL_LN9310_NODE); + struct i2c_common_emul_data *common_data = + emul_ln9310_get_i2c_common_data(emulator); + + struct startup_workaround_data test_data = { + .startup_workaround_attempted = false, + .startup_workaround_should_fail = true, + }; + + zassert_not_null(emulator, NULL); + + ln9310_emul_set_context(emulator); + ln9310_emul_reset(emulator); + /* + * Battery and chip rev won't matter for statement + * coverage here so only testing one pair. + */ + ln9310_emul_set_battery_cell_type(emulator, BATTERY_CELL_TYPE_2S); + ln9310_emul_set_version(emulator, + REQUIRES_CFLY_PRECHARGE_STARTUP_CHIP_REV); + + zassert_ok(ln9310_init(), NULL); + zassert_true(ln9310_emul_is_init(emulator), NULL); + + /* TODO(b/201420132) */ + k_msleep(TEST_DELAY_MS); + zassert_false(ln9310_power_good(), NULL); + + i2c_common_emul_set_write_func( + common_data, mock_write_fn_intercept_startup_workaround, + &test_data); + + ln9310_software_enable(true); + zassert_true(test_data.startup_workaround_attempted, NULL); + + /* TODO(b/201420132) */ + k_msleep(TEST_DELAY_MS); + zassert_false(ln9310_power_good(), NULL); + + i2c_common_emul_set_write_func(common_data, NULL, NULL); +} + +ZTEST(ln9310, test_ln9310_battery_unknown) +{ + const struct emul *emulator = EMUL_DT_GET(EMUL_LN9310_NODE); + + zassert_not_null(emulator, NULL); + + ln9310_emul_set_context(emulator); + ln9310_emul_reset(emulator); + /* + * Chip rev won't matter for statement + * cov so only testing one version. + */ + ln9310_emul_set_battery_cell_type(emulator, BATTERY_CELL_TYPE_UNKNOWN); + ln9310_emul_set_version(emulator, LN9310_BC_STS_C_CHIP_REV_FIXED); + + zassert_true(ln9310_init() != 0, NULL); + zassert_false(ln9310_emul_is_init(emulator), NULL); + + /* TODO(b/201420132) */ + k_msleep(TEST_DELAY_MS); + zassert_false(ln9310_power_good(), NULL); + + ln9310_software_enable(true); + + /* TODO(b/201420132) */ + k_msleep(TEST_DELAY_MS); + zassert_false(ln9310_power_good(), NULL); +} + +ZTEST(ln9310, test_ln9310_2s_battery_read_fails) +{ + const struct emul *emulator = EMUL_DT_GET(EMUL_LN9310_NODE); + struct i2c_common_emul_data *common_data = + emul_ln9310_get_i2c_common_data(emulator); + + zassert_not_null(emulator, NULL); + + ln9310_emul_set_context(emulator); + ln9310_emul_reset(emulator); + + ln9310_emul_set_battery_cell_type(emulator, BATTERY_CELL_TYPE_2S); + ln9310_emul_set_version(emulator, LN9310_BC_STS_C_CHIP_REV_FIXED); + + i2c_common_emul_set_read_fail_reg(common_data, LN9310_REG_BC_STS_B); + + zassert_true(ln9310_init() != 0, NULL); + zassert_false(ln9310_emul_is_init(emulator), NULL); + + /* TODO(b/201420132) */ + k_msleep(TEST_DELAY_MS); + zassert_false(ln9310_power_good(), NULL); + + /* For Battery 2S Versions: Test Read Battery Voltage Failure Too */ + ln9310_emul_reset(emulator); + ln9310_emul_set_battery_cell_type(emulator, BATTERY_CELL_TYPE_2S); + ln9310_emul_set_version(emulator, LN9310_BC_STS_C_CHIP_REV_FIXED); + + i2c_common_emul_set_read_fail_reg(common_data, LN9310_REG_TRACK_CTRL); + + zassert_false(ln9310_init() == 0, NULL); + i2c_common_emul_set_read_fail_reg(common_data, + I2C_COMMON_EMUL_NO_FAIL_REG); +} + +ZTEST(ln9310, test_ln9310_lion_ctrl_reg_fails) +{ + const struct emul *emulator = EMUL_DT_GET(EMUL_LN9310_NODE); + struct i2c_common_emul_data *common_data = + emul_ln9310_get_i2c_common_data(emulator); + + zassert_not_null(emulator, NULL); + + ln9310_emul_set_context(emulator); + ln9310_emul_reset(emulator); + /* Battery won't matter here so only testing one version */ + ln9310_emul_set_battery_cell_type(emulator, BATTERY_CELL_TYPE_2S); + ln9310_emul_set_version(emulator, LN9310_BC_STS_C_CHIP_REV_FIXED); + + i2c_common_emul_set_read_fail_reg(common_data, LN9310_REG_LION_CTRL); + + zassert_true(ln9310_init() != 0, NULL); + zassert_false(ln9310_emul_is_init(emulator), NULL); + + /* TODO(b/201420132) */ + k_msleep(TEST_DELAY_MS); + zassert_false(ln9310_power_good(), NULL); + + /* TODO(b/201420132) */ + k_msleep(TEST_DELAY_MS); + ln9310_software_enable(true); + zassert_false(ln9310_power_good(), NULL); + + i2c_common_emul_set_read_fail_reg(common_data, + I2C_COMMON_EMUL_NO_FAIL_REG); +} + +struct precharge_timeout_data { + timestamp_t time_to_mock; + bool handled_clearing_standby_en_bit_timeout; +}; + +static int mock_intercept_startup_ctrl_reg(const struct emul *emulator, int reg, + uint8_t val, int bytes, void *data) +{ + struct precharge_timeout_data *test_data = data; + + if (reg == LN9310_REG_STARTUP_CTRL && + test_data->handled_clearing_standby_en_bit_timeout == false) { + if (val == 0) { + timestamp_t time = get_time(); + + time.val += 1 + LN9310_CFLY_PRECHARGE_TIMEOUT; + test_data->time_to_mock = time; + get_time_mock = &test_data->time_to_mock; + } else { + /* ln9310 aborts a startup attempt */ + test_data->handled_clearing_standby_en_bit_timeout = + true; + get_time_mock = NULL; + } + } + return 1; +} + +ZTEST(ln9310, test_ln9310_cfly_precharge_timesout) +{ + const struct emul *emulator = EMUL_DT_GET(EMUL_LN9310_NODE); + struct i2c_common_emul_data *common_data = + emul_ln9310_get_i2c_common_data(emulator); + struct precharge_timeout_data test_data = { + .time_to_mock = { + .val = -1, + .le = { + .lo = -1, + .hi = -1, + }, + }, + .handled_clearing_standby_en_bit_timeout = false, + }; + + zassert_not_null(emulator, NULL); + + ln9310_emul_set_context(emulator); + ln9310_emul_reset(emulator); + /* Battery and chip rev won't matter here so only testing one pair */ + ln9310_emul_set_battery_cell_type(emulator, BATTERY_CELL_TYPE_2S); + ln9310_emul_set_version(emulator, + REQUIRES_CFLY_PRECHARGE_STARTUP_CHIP_REV); + + zassert_ok(ln9310_init(), NULL); + zassert_true(ln9310_emul_is_init(emulator), NULL); + + /* TODO(b/201420132) */ + k_msleep(TEST_DELAY_MS); + zassert_false(ln9310_power_good(), NULL); + + i2c_common_emul_set_write_func( + common_data, mock_intercept_startup_ctrl_reg, &test_data); + + ln9310_software_enable(true); + /* TODO(b/201420132) */ + k_msleep(TEST_DELAY_MS); + zassert_true(test_data.handled_clearing_standby_en_bit_timeout, NULL); + /* It only times out on one attempt, it should subsequently startup */ + zassert_true(ln9310_power_good(), NULL); + + i2c_common_emul_set_write_func(common_data, NULL, NULL); +} + +struct reg_to_fail_data { + int reg_access_to_fail; + int reg_access_fail_countdown; +}; + +static int mock_read_intercept_reg_to_fail(const struct emul *emul, int reg, + uint8_t *val, int bytes, void *data) +{ + struct reg_to_fail_data *test_data = data; + + if (reg == test_data->reg_access_to_fail) { + test_data->reg_access_fail_countdown--; + if (test_data->reg_access_fail_countdown <= 0) + return -1; + } + return 1; +} + +ZTEST(ln9310, test_ln9310_interrupt_reg_fail) +{ + const struct emul *emulator = EMUL_DT_GET(EMUL_LN9310_NODE); + struct i2c_common_emul_data *common_data = + emul_ln9310_get_i2c_common_data(emulator); + struct reg_to_fail_data test_data = { + .reg_access_to_fail = 0, + .reg_access_fail_countdown = 0, + }; + + zassert_not_null(emulator, NULL); + + ln9310_emul_set_context(emulator); + ln9310_emul_reset(emulator); + /* Battery and chip rev won't matter here so only testing one pair */ + ln9310_emul_set_battery_cell_type(emulator, BATTERY_CELL_TYPE_2S); + ln9310_emul_set_version(emulator, LN9310_BC_STS_C_CHIP_REV_FIXED); + + zassert_ok(ln9310_init(), NULL); + zassert_true(ln9310_emul_is_init(emulator), NULL); + + i2c_common_emul_set_read_func( + common_data, mock_read_intercept_reg_to_fail, &test_data); + + /* Fail in beginning of software enable */ + test_data.reg_access_to_fail = LN9310_REG_INT1; + test_data.reg_access_fail_countdown = 1; + + ln9310_software_enable(true); + + /* TODO(b/201420132) */ + k_msleep(TEST_DELAY_MS); + zassert_false(ln9310_power_good(), NULL); + zassert_true(test_data.reg_access_fail_countdown <= 0, NULL); + + /* Fail in irq interrupt handler */ + test_data.reg_access_fail_countdown = 2; + + ln9310_software_enable(true); + /* TODO(b/201420132) */ + k_msleep(TEST_DELAY_MS); + zassert_false(ln9310_power_good(), NULL); + zassert_true(test_data.reg_access_fail_countdown <= 0, NULL); + + i2c_common_emul_set_read_func(common_data, NULL, NULL); +} + +ZTEST(ln9310, test_ln9310_sys_sts_reg_fail) +{ + const struct emul *emulator = EMUL_DT_GET(EMUL_LN9310_NODE); + struct i2c_common_emul_data *common_data = + emul_ln9310_get_i2c_common_data(emulator); + struct reg_to_fail_data test_data = { + .reg_access_to_fail = 0, + .reg_access_fail_countdown = 0, + }; + + zassert_not_null(emulator, NULL); + + ln9310_emul_set_context(emulator); + ln9310_emul_reset(emulator); + /* Battery and chip rev won't matter here so only testing one pair */ + ln9310_emul_set_battery_cell_type(emulator, BATTERY_CELL_TYPE_2S); + ln9310_emul_set_version(emulator, LN9310_BC_STS_C_CHIP_REV_FIXED); + + zassert_ok(ln9310_init(), NULL); + zassert_true(ln9310_emul_is_init(emulator), NULL); + + i2c_common_emul_set_read_func( + common_data, &mock_read_intercept_reg_to_fail, &test_data); + + /* Register only read once and in the interrupt handler */ + test_data.reg_access_to_fail = LN9310_REG_SYS_STS; + test_data.reg_access_fail_countdown = 1; + + ln9310_software_enable(1); + + /* TODO(b/201420132) */ + k_msleep(TEST_DELAY_MS); + + zassert_false(ln9310_power_good(), NULL); + zassert_true(test_data.reg_access_fail_countdown <= 0, NULL); + + i2c_common_emul_set_read_func(common_data, NULL, NULL); +} + +struct reg_to_intercept { + int reg; + uint8_t replace_val; +}; + +static int mock_read_interceptor(const struct emul *emul, int reg, uint8_t *val, + int bytes, void *data) +{ + struct reg_to_intercept *test_data = data; + + if (test_data->reg == reg) { + *val = test_data->replace_val; + return 0; + } + + return 1; +} + +ZTEST(ln9310, test_ln9310_reset_explicit_detected_startup) +{ + const struct emul *emulator = EMUL_DT_GET(EMUL_LN9310_NODE); + struct i2c_common_emul_data *common_data = + emul_ln9310_get_i2c_common_data(emulator); + struct reg_to_intercept test_data = { + .reg = LN9310_REG_LION_CTRL, + .replace_val = 0, + }; + + zassert_not_null(emulator, NULL); + + ln9310_emul_set_context(emulator); + ln9310_emul_reset(emulator); + /* Battery and chip rev won't matter here so only testing one pair */ + ln9310_emul_set_battery_cell_type(emulator, BATTERY_CELL_TYPE_2S); + ln9310_emul_set_version(emulator, LN9310_BC_STS_C_CHIP_REV_FIXED); + + zassert_ok(ln9310_init(), NULL); + zassert_true(ln9310_emul_is_init(emulator), NULL); + + i2c_common_emul_set_read_func(common_data, &mock_read_interceptor, + &test_data); + + ln9310_software_enable(true); + + /* TODO(b/201420132) */ + k_msleep(TEST_DELAY_MS); + + zassert_true(ln9310_power_good(), NULL); + + i2c_common_emul_set_read_func(common_data, NULL, NULL); +} + +ZTEST(ln9310, test_ln9310_update_startup_seq_fails) +{ + const struct emul *emulator = EMUL_DT_GET(EMUL_LN9310_NODE); + struct i2c_common_emul_data *common_data = + emul_ln9310_get_i2c_common_data(emulator); + struct reg_to_fail_data test_data = { + .reg_access_to_fail = LN9310_REG_CFG_4, + .reg_access_fail_countdown = 1, + }; + + zassert_not_null(emulator, NULL); + + ln9310_emul_set_context(emulator); + ln9310_emul_reset(emulator); + /* Battery won't matter here so only testing one pair */ + ln9310_emul_set_battery_cell_type(emulator, BATTERY_CELL_TYPE_2S); + /* Requires older version of chip */ + ln9310_emul_set_version(emulator, + REQUIRES_CFLY_PRECHARGE_STARTUP_CHIP_REV); + + i2c_common_emul_set_read_func( + common_data, &mock_read_intercept_reg_to_fail, &test_data); + + zassert_false(ln9310_init() == 0, NULL); + zassert_false(ln9310_emul_is_init(emulator), NULL); + + ln9310_software_enable(true); + + /* TODO(b/201420132) */ + k_msleep(TEST_DELAY_MS); + + zassert_false(ln9310_power_good(), NULL); + zassert_true(test_data.reg_access_fail_countdown <= 0, NULL); + + i2c_common_emul_set_read_func(common_data, NULL, NULL); +} + +ZTEST(ln9310, test_ln9310_state_change_only_on_mode_change_interrupt) +{ + const struct emul *emulator = EMUL_DT_GET(EMUL_LN9310_NODE); + struct i2c_common_emul_data *common_data = + emul_ln9310_get_i2c_common_data(emulator); + struct reg_to_intercept test_data = { + .reg = LN9310_REG_INT1, + .replace_val = 0, + }; + + zassert_not_null(emulator, NULL); + + ln9310_emul_set_context(emulator); + ln9310_emul_reset(emulator); + /* Battery and chip rev won't matter here so only testing one pair */ + ln9310_emul_set_battery_cell_type(emulator, BATTERY_CELL_TYPE_2S); + ln9310_emul_set_version(emulator, LN9310_BC_STS_C_CHIP_REV_FIXED); + + zassert_ok(ln9310_init(), NULL); + zassert_true(ln9310_emul_is_init(emulator), NULL); + + i2c_common_emul_set_read_func(common_data, &mock_read_interceptor, + &test_data); + + ln9310_software_enable(true); + + /* TODO(b/201420132) */ + k_msleep(TEST_DELAY_MS); + + zassert_false(ln9310_power_good(), NULL); + + i2c_common_emul_set_read_func(common_data, NULL, NULL); +} + +static inline void reset_ln9310_state(void) +{ + ln9310_reset_to_initial_state(); + get_time_mock = NULL; +} + +static void ln9310_before(void *state) +{ + ARG_UNUSED(state); + reset_ln9310_state(); +} + +static void ln9310_after(void *state) +{ + ARG_UNUSED(state); + reset_ln9310_state(); +} + +ZTEST_SUITE(ln9310, drivers_predicate_post_main, NULL, ln9310_before, + ln9310_after, NULL); |