Does anyone use the Atmel AT24 driver for ST M24xxx eeprom?

[Schulz-Jakob]

Hi everyone,
I'm currently trying to use the ST M24256-DRE EEPROM with the Atmel AT24 driver but I get wrong read data via I2C when I try to read and write the eeprom several times in a row.
As far as the atmel,at24.yaml says, the ST M24xxx family is compatible with the Atmel AT24 driver.

I'm assuming that there is an error with the acknowledge polling when trying to read the eeprom data. Some eeprom only accept ack polling with a write command (just like the ST M24256-DRE).

Has anyone already tried the driver for this EEPROM or for this EEPROM family to confirm that the error is on my side?

Sorry in advance, I am new to zephyr and firmware development

Thanks
Jakob

Datasheet:
m24256-dre.pdf

Devicetree configuration:

The deviectree configuration of the i2c is split into two files

i2c1: i2c@400f2000 {
			compatible = "ti,mspm0-i2c";
			clock-frequency = <I2C_BITRATE_STANDARD>;
			#address-cells = <1>;
			#size-cells = <0>;
			reg = <0x400f2000 0x2000>;
			interrupts = <25 0>;
			clocks = <&clkmux MSPM0_CLOCK_BUS_ULPCLK>;
			status = "disabled";
};

I2C_BITRATE_STANDARD has the value 100000

&i2c0 {
	status = "disabled";
};

&i2c1 {
	status = "okay";
	pinctrl-0 = <&i2c1_sda_pa10 &i2c1_scl_pa11>;
	pinctrl-names = "default";

	eeprom0: eeprom@50 {
		compatible = "st,m24256dre","st,m24xxx", "atmel,at24";
		reg = <0x50>;
		status = "okay";
		size = <32768>;
		pagesize = <64>;
		address-width = <16>;
		timeout = <100>;
	};
};

&clk_out {
	pinctrl-0 = <&clk_out_pa7>;
	pinctrl-names = "default";
};

&pinctrl {
	clk_out_pa7: clk_out_pa7 {
		pinmux = <MSP_PINMUX(14,MSPM0_PIN_FUNCTION_3)>;
	};	
	
	i2c1_sda_pa10: i2c1_sda_pa10 {
		pinmux = <MSP_PINMUX(21,MSPM0_PIN_FUNCTION_8)>;
		input-enable;
		/* no internal pull up needed */
		drive-open-drain;
	};

	i2c1_scl_pa11: i2c1_scl_pa11 {
		pinmux = <MSP_PINMUX(22,MSPM0_PIN_FUNCTION_8)>;
		input-enable;
		/* no internal pull up needed */
		drive-open-drain;
	};
};

Example code:

/***************************************************************************
 * INCLUDES
 ***************************************************************************/
#include <system/sysctrl.h>
#include <main.h>

/* std includes */
#include <stdio.h>
#include <string.h>

/* Zephyr includes */
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/logging/log.h>
#include <zephyr/drivers/eeprom.h>

LOG_MODULE_REGISTER(system_control, CONFIG_APP_LOG_LEVEL);

/***************************************************************************
 * DEFINES
 ***************************************************************************/
#define SYSCTRL_STACK_SIZE 512
#define SYSCTRL_PRIORITY   2
K_THREAD_STACK_DEFINE(sysctrl_stack_area, SYSCTRL_STACK_SIZE);
static struct k_thread sysctrl_thread_data;

static k_tid_t mg_sysctrl_tid = NULL;

static const struct device *const eepromDriver = DEVICE_DT_GET(DT_ALIAS(eeprom_0));

/***************************************************************************
 * FUNCTION DECLARATIONS
 ***************************************************************************/
static void SysCtrl_thread(void *arg1, void *arg2, void *arg3);

/***************************************************************************
 * FUNCTION IMPLEMENTATIONS
 ***************************************************************************/
void SysCtrl_init(void)
{
	mg_sysctrl_tid = k_thread_create(&sysctrl_thread_data, sysctrl_stack_area,
					 K_THREAD_STACK_SIZEOF(sysctrl_stack_area), SysCtrl_thread,
					 NULL, NULL, NULL, SYSCTRL_PRIORITY, 0, K_NO_WAIT);
}

static void SysCtrl_thread(void *arg1, void *arg2, void *arg3)
{

	LOG_INF("Sysctrl Init\r\n\r\n");

	if (!device_is_ready(eepromDriver)) {
		LOG_ERR("\nError: Device \"%s\" is not ready; "
			"check the driver initialization logs for errors.\n",
			eepromDriver->name);
	}
	uint16_t input = 42;
	uint16_t result = 0;
	uint16_t ret = 0;
	for (int i = 0; i < 30; i++) {
		ret = eeprom_write(eepromDriver, 0, &input, sizeof(uint16_t));
		ret |= eeprom_read(eepromDriver, 0, &result, sizeof(uint16_t));
		if(ret != 0){
			LOG_DBG("return error %i", ret);
			break;
		}
		if (result != input) {
			LOG_DBG("output error %i: %i", i, result);
		}
		result = 0;
	}
	LOG_DBG("Finished");
};

Debug output (Segger RTT)

Eeprom driver modification

I have adapted the eeprom driver code and the data is read out correctly

diff --git a/drivers/eeprom/eeprom_at2x.c b/drivers/eeprom/eeprom_at2x.c
index 94596c86d1e..e042cd4cecb 100644
--- a/drivers/eeprom/eeprom_at2x.c
+++ b/drivers/eeprom/eeprom_at2x.c
@@ -264,7 +264,7 @@ static int eeprom_at24_read(const struct device *dev, off_t offset, void *buf,
 	int64_t timeout;
 	uint8_t addr[2];
 	uint16_t bus_addr;
-	int err;
+	int err = 0;
 
 	bus_addr = eeprom_at24_translate_offset(dev, &offset);
 
@@ -277,20 +277,20 @@ static int eeprom_at24_read(const struct device *dev, off_t offset, void *buf,
 	len = eeprom_at24_adjust_read_count(dev, offset, len);
 
 	/*
-	 * A write cycle may be in progress so reads must be attempted
+	 * A write cycle may be in progress so writes must be attempted
 	 * until the current write cycle should be completed.
 	 */
 	timeout = k_uptime_get() + config->timeout;
-	while (1) {
-		int64_t now = k_uptime_get();
-		err = i2c_write_read(config->bus.i2c.bus, bus_addr,
+	while (k_uptime_get() < timeout) {
+        err = i2c_write(config->bus.i2c.bus, NULL, 0, bus_addr); // Only send device address
+        if (!err) {
+			err = i2c_write_read(config->bus.i2c.bus, bus_addr,
 				     addr, config->addr_width / 8,
 				     buf, len);
-		if (!err || now > timeout) {
-			break;
-		}
-		k_sleep(K_MSEC(1));
-	}
+            break;
+        }
+        k_sleep(K_MSEC(1));
+    }
 
 	if (err < 0) {
 		return err;

Debug output after modification (Segger RTT)