Files
rtems/bsps/shared/dev/i2c/eeprom.c
T
Michal Lenc 7f98bd8469 i2c: move drivers from cpukit to bsps/shared
More i2c drivers from cpukit to bsps/shared to allow them use BSP
infrastructure if needed. The framework code i2c-bus.c and i2c-dev.c
kept at its original location.

Signed-off-by: Michal Lenc <michallenc@seznam.cz>
2026-07-02 18:33:01 -05:00

287 lines
7.1 KiB
C

/**
* @file
*
* @brief EEPROM Driver Implementation
*
* @ingroup I2CEEPROM
*/
/*
* Copyright (C) 2014 embedded brains GmbH & Co. KG
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <dev/i2c/eeprom.h>
#include <string.h>
#define EEPROM_MAX_ADDRESS_BYTES 4
#define EEPROM_MAX_PAGE_SIZE 128
typedef struct {
i2c_dev base;
uint16_t address_bytes;
uint16_t page_size;
uint32_t size;
uint16_t i2c_address_mask;
uint16_t i2c_address_shift;
rtems_interval program_timeout_in_ticks;
} eeprom;
static uint16_t eeprom_i2c_addr( eeprom *dev, uint32_t off )
{
return dev->base.address |
( ( off >> dev->i2c_address_shift ) & dev->i2c_address_mask );
}
static void eeprom_set_addr(
const eeprom *dev,
uint32_t off,
uint8_t addr[ EEPROM_MAX_ADDRESS_BYTES ]
)
{
int shift = 24 - ( 4 - dev->address_bytes ) * 8;
addr[ 0 ] = (uint8_t) ( off >> shift );
shift -= 8;
addr[ 1 ] = (uint8_t) ( off >> shift );
shift -= 8;
addr[ 2 ] = (uint8_t) ( off >> shift );
shift -= 8;
addr[ 3 ] = (uint8_t) ( off >> shift );
}
static ssize_t eeprom_read( i2c_dev *base, void *buf, size_t n, off_t offset )
{
eeprom *dev = (eeprom *) base;
off_t avail = dev->size - offset;
uint32_t off = (uint32_t) offset;
uint8_t *in = buf;
size_t todo;
if ( avail <= 0 ) {
return 0;
}
if ( n > (size_t) avail ) {
n = (size_t) avail;
}
todo = n;
while ( todo > 0 ) {
uint16_t i2c_addr = eeprom_i2c_addr( dev, off );
/*
* Limit the transfer size so that it can be stored in 8-bits. This may
* help some bus controllers.
*/
uint16_t cur = (uint16_t) ( todo < 255 ? todo : 255 );
uint8_t addr[ EEPROM_MAX_ADDRESS_BYTES ];
i2c_msg msgs[ 2 ] = {
{ .addr = i2c_addr,
.flags = 0,
.len = dev->address_bytes,
.buf = &addr[ 0 ] },
{ .addr = i2c_addr, .flags = I2C_M_RD, .buf = in, .len = cur }
};
int err;
eeprom_set_addr( dev, off, addr );
err = i2c_bus_transfer(
dev->base.bus,
&msgs[ 0 ],
RTEMS_ARRAY_SIZE( msgs )
);
if ( err != 0 ) {
return err;
}
todo -= cur;
off += cur;
in += cur;
}
return (ssize_t) n;
}
static ssize_t eeprom_write(
i2c_dev *base,
const void *buf,
size_t n,
off_t offset
)
{
eeprom *dev = (eeprom *) base;
off_t avail = dev->size - offset;
uint32_t off = (uint32_t) offset;
const uint8_t *out = buf;
size_t todo;
if ( avail <= 0 ) {
return 0;
}
if ( n > (size_t) avail ) {
n = (size_t) avail;
}
todo = n;
while ( todo > 0 ) {
uint16_t i2c_addr = eeprom_i2c_addr( dev, off );
uint16_t rem = dev->page_size - ( off & ( dev->page_size - 1 ) );
uint16_t cur = (uint16_t) ( todo < rem ? todo : rem );
uint8_t addr[ EEPROM_MAX_ADDRESS_BYTES ];
i2c_msg msgs[ 2 ] = {
{ .addr = i2c_addr,
.flags = 0,
.len = dev->address_bytes,
.buf = &addr[ 0 ] },
{ .addr = i2c_addr,
.flags = I2C_M_NOSTART,
.buf = RTEMS_DECONST( uint8_t *, out ),
.len = cur }
};
uint8_t in[ EEPROM_MAX_PAGE_SIZE ];
int err;
ssize_t m;
rtems_interval timeout;
bool before;
eeprom_set_addr( dev, off, addr );
err = i2c_bus_transfer(
dev->base.bus,
&msgs[ 0 ],
RTEMS_ARRAY_SIZE( msgs )
);
if ( err != 0 ) {
return err;
}
timeout = rtems_clock_tick_later( dev->program_timeout_in_ticks );
do {
before = rtems_clock_tick_before( timeout );
m = eeprom_read( &dev->base, &in[ 0 ], cur, off );
if ( m == cur ) {
break;
}
} while ( before );
if ( m != cur ) {
return -ETIMEDOUT;
}
if ( memcmp( &in[ 0 ], &out[ 0 ], cur ) != 0 ) {
return -EIO;
}
todo -= cur;
off += cur;
out += cur;
}
return (ssize_t) n;
}
static off_t eeprom_get_size( i2c_dev *base )
{
eeprom *dev = (eeprom *) base;
return dev->size;
}
static blksize_t eeprom_get_block_size( i2c_dev *base )
{
eeprom *dev = (eeprom *) base;
return dev->page_size;
}
int i2c_dev_register_eeprom(
const char *bus_path,
const char *dev_path,
uint16_t i2c_address,
uint16_t address_bytes,
uint16_t page_size_in_bytes,
uint32_t size_in_bytes,
uint32_t program_timeout_in_ms
)
{
uint32_t extra_address;
uint32_t ms_per_tick;
eeprom *dev;
if ( address_bytes > EEPROM_MAX_ADDRESS_BYTES ) {
rtems_set_errno_and_return_minus_one( ERANGE );
} else if ( address_bytes == EEPROM_MAX_ADDRESS_BYTES ) {
extra_address = 0;
} else {
extra_address = size_in_bytes >> ( 8 * address_bytes );
}
if ( extra_address != 0 && ( extra_address & ( extra_address - 1 ) ) != 0 ) {
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( page_size_in_bytes > EEPROM_MAX_PAGE_SIZE ) {
page_size_in_bytes = EEPROM_MAX_PAGE_SIZE;
}
if ( program_timeout_in_ms == 0 ) {
program_timeout_in_ms = 1000;
}
dev = (eeprom *)
i2c_dev_alloc_and_init( sizeof( *dev ), bus_path, i2c_address );
if ( dev == NULL ) {
return -1;
}
dev->base.read = eeprom_read;
dev->base.write = eeprom_write;
dev->base.get_size = eeprom_get_size;
dev->base.get_block_size = eeprom_get_block_size;
dev->address_bytes = address_bytes;
dev->page_size = page_size_in_bytes;
dev->size = size_in_bytes;
ms_per_tick = rtems_configuration_get_milliseconds_per_tick();
dev->program_timeout_in_ticks = ( program_timeout_in_ms + ms_per_tick - 1 ) /
ms_per_tick +
1;
if ( extra_address != 0 ) {
dev->i2c_address_mask = extra_address - 1;
dev->i2c_address_shift = (uint16_t) ( 8 * address_bytes );
}
return i2c_dev_register( &dev->base, dev_path );
}