mirror of
https://gitlab.rtems.org/rtems/rtos/rtems.git
synced 2026-11-16 19:04:53 +08:00
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>
287 lines
7.1 KiB
C
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 );
|
|
}
|