CST816S input driver i2c failed to read

[nanangcreacoll]

I have problem with i2c that can't read the cst816s, its always return log message `<err> cst816s: failed reading chip id` and `<err> cst816s: Could not read x data` when touched. i'm using the nRF52832. is there any configuration i need to do?

the board device tree: 

/dts-v1/;
#include <nordic/nrf52832_qfaa.dtsi>

...

&flash0 {
	partitions {
		compatible = "fixed-partitions";
		#address-cells = <1>;
		#size-cells = <1>;

		boot_partition: partition@0 {
			label = "mcuboot";
			reg = <0x00000000 DT_SIZE_K(48)>;
		};

		slot0_partition: partition@c000 {
			label = "image-0";
			reg = <0x0000c000 DT_SIZE_K(220)>;
		};

		slot1_partition: partition@43000 {
			label = "image-1";
			reg = <0x00043000 DT_SIZE_K(220)>;
		};

		storage_partition: partition@7a000 {
			label = "storage";
			reg = <0x0007a000 DT_SIZE_K(24)>;
		};
	};
};
&gpio0 {
	status = "okay";
};

&gpiote {
	status = "okay";
};

&rtc2 {
	status = "okay";
};

&uart0 {
	status = "okay";
	pinctrl-0 = <&uart0_default>;
	pinctrl-1 = <&uart0_sleep>;
	pinctrl-names = "default", "sleep";
	current-speed = <115200>;
};

&i2c1 {
	status = "okay";
	pinctrl-0 = <&i2c1_default>;
	pinctrl-1 = <&i2c1_sleep>;
	pinctrl-names = "default", "sleep";
};

the pinctrl file:

&pinctrl {
	uart0_default: uart0_default {
		group1 {
			psels = <NRF_PSEL(UART_TX, 0, 24)>, <NRF_PSEL(UART_RX, 0, 23)>;
		};
	};

	uart0_sleep: uart0_sleep {
		group1 {
			psels = <NRF_PSEL(UART_TX, 0, 24)>, <NRF_PSEL(UART_RX, 0, 23)>;
			low-power-enable;
		};
	};

	spi0_default: spi0_default {
		group1 {
			psels = <NRF_PSEL(SPIM_MOSI, 0, 29)>, <NRF_PSEL(SPIM_SCK, 0, 28)>;
		};
	};

	spi0_sleep: spi0_sleep {
		group1 {
			psels = <NRF_PSEL(SPIM_MOSI, 0, 29)>, <NRF_PSEL(SPIM_SCK, 0, 28)>;
			low-power-enable;
		};
	};

	i2c1_sleep: i2c1_sleep {
		group1 {
			psels = <NRF_PSEL(TWIM_SDA, 0, 9)>, <NRF_PSEL(TWIM_SCL, 0, 10)>;
			low-power-enable;
		};
	};

	i2c1_default: i2c1_default {
		group1 {
			psels = <NRF_PSEL(TWIM_SDA, 0, 9)>, <NRF_PSEL(TWIM_SCL, 0, 10)>;
		};
	};
};

the overlay file:

/ {
    chosen {
        zephyr,display = &display;
        zephyr,keyboard-scan = &touch_screen;
    };

    aliases {
        input = &touch_screen;
    };

    leds {
        compatible = "gpio-leds";
        lcd_backlight: lcd_backlight {
            gpios = <&gpio0 11 GPIO_ACTIVE_LOW>;
            label = "LCD Backlight";
        };
    };

    lvgl_pointer_input:lvgl_pointer {
        compatible = "zephyr,lvgl-pointer-input";
        input = <&touch_screen>;
    };
};

&spi0 {
    compatible = "nordic,nrf-spim";
	status = "okay";
	pinctrl-0 = <&spi0_default>;
	pinctrl-1 = <&spi0_sleep>;
	pinctrl-names = "default", "sleep";
	cs-gpios = <&gpio0 30 GPIO_ACTIVE_LOW>;

	display: st7789v@0 {
        label = "ST7789 Display";
		compatible = "sitronix,st7789v";
        spi-max-frequency = <20000000>;
        reg = <0>;
        cmd-data-gpios = < &gpio0 27 GPIO_ACTIVE_LOW>;
        reset-gpios = < &gpio0 31 GPIO_ACTIVE_LOW>;
        width = <240>;
        height = <240>;
        x-offset = <0>;
        y-offset = <0>;
        vcom = <0x19>;
        gctrl = <0x35>;
        vrhs = <0x12>;
        vdvs = <0x20>;
        mdac = <0x00>;
        gamma = <0x01>;
        colmod = <0x05>;
        lcm = <0x2c>;
        porch-param = [0c 0c 00 33 33];
        cmd2en-param = [5a 69 02 01];
        pwctrl1-param = [a4 a1];
        pvgam-param = [D0 04 0D 11 13 2B 3F 54 4C 18 0D 0B 1F 23];
        nvgam-param = [D0 04 0C 11 13 2C 3F 44 51 2F 1F 1F 20 23];
        ram-param = [00 F0];
        rgb-param = [CD 08 14];
	};
};

&i2c1 {
    clock-frequency = <I2C_BITRATE_FAST>;

    touch_screen: cst186s@15 {
        label = "CST816S Touch Screen";
        status = "okay";
        compatible = "hynitron,cst816s";
        reg = <0x15>;
        irq-gpios = <&gpio0 26 GPIO_ACTIVE_LOW>;
        rst-gpios = <&gpio0 21 GPIO_ACTIVE_LOW>;
    };
};

[Sigurd Hellesvik]

Hi,

Are you able to get logic analyzer or oscilloscope readings from the I2C?

Regards,
Sigurd Hellesvik

[nanangcreacoll]

Hi, thanks for your response. As you can see, there is nothing on the i2c reading with zephyr. I have tried it with other frameworks and it still works fine. I'm still curious what makes i2c (with gpio sda 9 and gpio scl 10) not output any data, maybe I missed something when setting up the board devicetree or overlay.

I2c readings with other framework:

I2c readings with zephyr:

[Sigurd Hellesvik]

Looks like you are using the cst816s drivers directly.
I found a Zephyr issue where another user has exactly the same issue:
https://github.com/zephyrproject-rtos/zephyr/discussions/74678. Im not sure if it is related or not, but worth knowing about.

nanangcreacoll said:

I2c readings with other framework:

This is good to know. It shows that the hardware works correctly, and that this is a software issue.

I suggest that you start by trying to use I2C directly to read the device ID.
You can do this by following the DevAcademy Fundamentals: I2C lesson. 

This way, you get some firmware to compare with. Then we can compare the working I2C with the cst816s driver.

[nanangcreacoll]

Here I try directly using I2C to initialize CST816S. I try to make my own device tree binding for CST816S. I still don't know which part I should fix, I2C still can't read the chip. RST and IRQ gpio work fine.

overlay file:

&i2c1 {
	cst816s: cst816s@15 {
		compatible = "cst816s";
		status = "okay";
		reg = <0x15>;
		irq-gpios = <&gpio0 26 GPIO_ACTIVE_LOW>;
		rst-gpios = <&gpio0 21 GPIO_ACTIVE_LOW>;
	};
};

main code:

#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/devicetree.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/i2c.h>

#define LOG_LEVEL LOG_LEVEL_DBG
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(app, LOG_LEVEL);

#define CST816S_NODE DT_NODELABEL(cst816s)

#define CST816S_I2C_ADDR 0x15
#define CST816S_I2C_CHIP_ID_REG 0xA7

struct cst816s_data
{
        const struct i2c_dt_spec *i2c;
        struct k_work work;
        struct gpio_callback irq_gpio_cb;
};

static int cst816s_reset(const struct gpio_dt_spec *rst_gpio)
{
        LOG_DBG("CST816S Reset");

        int ret;

        if (!gpio_is_ready_dt(rst_gpio))
        {
                LOG_ERR("RST GPIO not ready");
                return -ENODEV;
        }

        ret = gpio_pin_configure_dt(rst_gpio, GPIO_OUTPUT);
        if (ret < 0)
        {
                LOG_ERR("Failed to configure RST GPIO: %d", ret);
                return ret;
        }
        
        ret = gpio_pin_set_dt(rst_gpio, 1);
        if (ret < 0)
        {
                LOG_ERR("Failed to set RST GPIO: %d", ret);
                return ret;
        }
        k_msleep(5);
        ret = gpio_pin_set_dt(rst_gpio, 0);
        if (ret < 0)
        {
                LOG_ERR("Failed to set RST GPIO: %d", ret);
                return ret;
        }
        k_msleep(50);

        return 0;
}

static void cst816s_irq_handler(const struct device *dev, struct gpio_callback *cb, uint32_t pins)
{
        struct cst816s_data *data = CONTAINER_OF(cb, struct cst816s_data, irq_gpio_cb);

        k_work_submit(&data->work);
}

static int cst816s_irq_init(const struct gpio_dt_spec *irq_gpio, struct gpio_callback *irq_gpio_cb)
{
        LOG_DBG("CST816S IRQ Initialization");

        int ret;

        if (!gpio_is_ready_dt(irq_gpio))
        {
                LOG_ERR("IRQ GPIO not ready");
                return -ENODEV;
        }

        ret = gpio_pin_configure_dt(irq_gpio, GPIO_INPUT);
        if (ret < 0)
        {
                LOG_ERR("Failed to configure IRQ GPIO: %d", ret);
                return ret;
        }

        ret = gpio_pin_interrupt_configure_dt(irq_gpio, GPIO_INT_EDGE_TO_ACTIVE);
        if (ret < 0)
        {
                LOG_ERR("Failed to configure IRQ GPIO interrupt: %d", ret);
                return ret;
        }

        gpio_init_callback(irq_gpio_cb, cst816s_irq_handler, BIT(irq_gpio->pin));
        ret = gpio_add_callback(irq_gpio->port, irq_gpio_cb);
        if (ret < 0)
        {
                LOG_ERR("Failed to add IRQ GPIO callback: %d", ret);
                return ret;
        }

        return 0;
}

static int cst816s_process(const struct i2c_dt_spec *cst816s)
{
        LOG_DBG("CST816S Process");

        if (!i2c_is_ready_dt(cst816s))
        {
                LOG_ERR("CST816S I2C device not ready");
                return -ENODEV;
        }

        return 0;
}

static void cst816s_work_handler(struct k_work *work)
{
        struct cst816s_data *data = CONTAINER_OF(work, struct cst816s_data, work);
        
        cst816s_process(data->i2c);
}

static int cst816s_init (const struct i2c_dt_spec *cst816s, const struct gpio_dt_spec *rst_gpio, const struct gpio_dt_spec *irq_gpio, struct cst816s_data *data)
{
        LOG_DBG("CST816S Initialization");

        int ret;
        uint8_t chip_id = 0;

        ret = cst816s_reset(rst_gpio);
        if (ret < 0)
        {
                LOG_ERR("Failed to reset CST816S chip: %d", ret);
                return ret;
        }
        LOG_DBG("CST816S Chip Reset complete");

        ret = cst816s_irq_init(irq_gpio, &data->irq_gpio_cb);
        if (ret < 0)
        {
                LOG_ERR("Failed to initialize CST816S IRQ: %d", ret);
                return ret;
        }
        LOG_DBG("CST816S IRQ initialized successfully");

        ret = i2c_reg_read_byte_dt(cst816s, CST816S_I2C_CHIP_ID_REG, &chip_id);
        if (ret < 0)
        {
                LOG_ERR("Failed to read chip ID: %d", ret);
                return ret;
        }
        LOG_DBG("CST816S Chip ID: 0x%02X", chip_id);

        return 0;
}

int main()
{
        LOG_DBG("CST816S Touchscreen I2C Test");

        const struct i2c_dt_spec cst816s_i2c = I2C_DT_SPEC_GET(CST816S_NODE);
        if (!i2c_is_ready_dt(&cst816s_i2c))
        {
                LOG_ERR("CST816S I2C device not ready");
                return -ENODEV;
        }
        LOG_DBG("CST816S I2C device (bus %d, addr 0x%02X)", cst816s_i2c.bus->name, cst816s_i2c.addr);

        const struct gpio_dt_spec cst816s_rst_gpio = GPIO_DT_SPEC_GET(CST816S_NODE, rst_gpios);
        if (!gpio_is_ready_dt(&cst816s_rst_gpio))
        {
                LOG_ERR("RST GPIO not ready");
                return -ENODEV;
        }
        LOG_DBG("RST GPIO (port %d, pin %d)", cst816s_rst_gpio.port->name, cst816s_rst_gpio.pin);
        const struct gpio_dt_spec cst816s_irq_gpio = GPIO_DT_SPEC_GET(CST816S_NODE, irq_gpios);
        if (!gpio_is_ready_dt(&cst816s_irq_gpio))
        {
                LOG_ERR("IRQ GPIO not ready");
                return -ENODEV;
        }
        LOG_DBG("IRQ GPIO (port %d, pin %d)", cst816s_irq_gpio.port->name, cst816s_irq_gpio.pin);

        struct cst816s_data data;
        data.i2c = &cst816s_i2c;

        k_work_init(&data.work, cst816s_work_handler);

        int ret;

        ret = cst816s_init(&cst816s_i2c, &cst816s_rst_gpio, &cst816s_irq_gpio, &data);
        if (ret < 0)
        {
                LOG_ERR("Failed to initialize CST816S: %d", ret);
                return ret;
        }
        LOG_DBG("CST816S initialized successfully");

        while(1)
        {
                k_msleep(1);
        }

        return 0;
}

log output:

*** Booting nRF Connect SDK v2.7.0-5cb85570ca43 ***
*** Using Zephyr OS v3.6.99-100befc70c74 ***
[00:00:00.431,335] <dbg> app: main: CST816S Touchscreen I2C Test
[00:00:00.431,365] <dbg> app: main: CST816S I2C device (bus i2c@40004000, addr 0x15)
[00:00:00.431,396] <dbg> app: main: RST GPIO (port gpio@50000000, pin 21)
[00:00:00.431,427] <dbg> app: main: IRQ GPIO (port gpio@50000000, pin 26)
[00:00:00.431,457] <dbg> app: cst816s_init: CST816S Initialization
[00:00:00.431,457] <dbg> app: cst816s_reset: CST816S Reset
[00:00:00.486,633] <dbg> app: cst816s_init: CST816S Chip Reset complete
[00:00:00.486,663] <dbg> app: cst816s_irq_init: CST816S IRQ Initialization
[00:00:00.486,694] <dbg> app: cst816s_init: CST816S IRQ initialized successfully
[00:00:00.486,785] <err> app: Failed to read chip ID: -5
[00:00:00.486,816] <err> app: Failed to initialize CST816S: -5
[00:16:50.213,226] <dbg> app: cst816s_process: CST816S Process

[Sigurd Hellesvik]

nanangcreacoll said:

I try directly using I2C to initialize CST816S. I try to make my own device tree binding for CST816S. I still don't know which part I should fix, I2C still can't read the chip. RST and IRQ gpio work fine.

Alright, then we have tried two different ways to read the CST816S over I2C.

At this point, I think it would be a good idea to look at the hardware.

How do you connect the CST to the nRF?
Do you have another I2C device that you can try to read with the nRF, to verify that the I2C code work?