mirror of
https://gitee.com/mirrors_PX4/PX4-Autopilot.git
synced 2026-10-15 18:13:34 +08:00
Clean out remains of the old EEPROM driver.
This commit is contained in:
px4dev
@@ -1,60 +0,0 @@
|
||||
/****************************************************************************
|
||||
*
|
||||
* Copyright (C) 2012 PX4 Development Team. All rights reserved.
|
||||
*
|
||||
* 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.
|
||||
* 3. Neither the name PX4 nor the names of its contributors may be
|
||||
* used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
/**
|
||||
* @file drv_eeprom.h
|
||||
*
|
||||
* Config for the non-MTD EEPROM driver.
|
||||
*/
|
||||
|
||||
/* IMPORTANT: Adjust this number! */
|
||||
#define MAX_EEPROMS 2
|
||||
|
||||
/* FMU onboard */
|
||||
#define FMU_BASEBOARD_EEPROM_ADDRESS 0x57
|
||||
#define FMU_BASEBOARD_EEPROM_TOTAL_SIZE_BYTES 128
|
||||
#define FMU_BASEBOARD_EEPROM_PAGE_SIZE_BYTES 8
|
||||
#define FMU_BASEBOARD_EEPROM_PAGE_WRITE_TIME_US 3300
|
||||
#define FMU_BASEBOARD_EEPROM_BUS_CLOCK 400000 ///< 400 KHz max. clock
|
||||
|
||||
/**
|
||||
* @brief i2c I2C bus struct
|
||||
* @brief device_address The device address as stated in the datasheet, e.g. for a Microchip 24XX128 0x50 with all ID pins tied to GND
|
||||
* @brief total_size_bytes The total size in bytes, e.g. 16K = 16000 bytes for the Microchip 24XX128
|
||||
* @brief page_size_bytes The size of one page, e.g. 64 bytes for the Microchip 24XX128
|
||||
* @brief device_name The device name to register this device to, e.g. /dev/eeprom
|
||||
* @brief fail_if_missing Returns error if the EEPROM was not found. This is helpful if the EEPROM might be attached later when the board is running
|
||||
*/
|
||||
extern int
|
||||
eeprom_attach(struct i2c_dev_s *i2c, uint8_t device_address, uint16_t total_size_bytes, uint16_t page_size_bytes, uint16_t page_write_time_us, const char* device_name, uint8_t fail_if_missing);
|
||||
|
||||
@@ -41,7 +41,7 @@ ASRCS =
|
||||
AOBJS = $(ASRCS:.S=$(OBJEXT))
|
||||
|
||||
CSRCS = up_leds.c \
|
||||
drv_led.c drv_eeprom.c
|
||||
drv_led.c
|
||||
|
||||
COBJS = $(CSRCS:.c=$(OBJEXT))
|
||||
|
||||
|
||||
@@ -1,522 +0,0 @@
|
||||
/*
|
||||
* Copyright (C) 2012 Lorenz Meier. All rights reserved.
|
||||
*
|
||||
* 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.
|
||||
* 3. Neither the name of the author or the names of contributors may be
|
||||
* used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Generic driver for I2C EEPROMs with 8 bit or 16 bit addressing
|
||||
*/
|
||||
|
||||
#include <nuttx/config.h>
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
#include <debug.h>
|
||||
#include <errno.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include <nuttx/i2c.h>
|
||||
#include <arch/board/board.h>
|
||||
|
||||
#include "up_arch.h"
|
||||
#include "chip.h"
|
||||
#include "stm32_internal.h"
|
||||
#include "px4fmu-internal.h"
|
||||
|
||||
#include <arch/board/drv_eeprom.h>
|
||||
|
||||
/* Split I2C transfers into smaller chunks to make sure to stay within tight timeout limits */
|
||||
|
||||
/* check defines */
|
||||
#ifndef MAX_EEPROMS
|
||||
#error MAX_EEPROMS number must be defined (1-3)
|
||||
#endif
|
||||
|
||||
#if (MAX_EEPROMS > 3)
|
||||
#error Currently only a maximum of three EEPROMS is supported, add missing code around here: __FILE__:__LINE__
|
||||
#endif
|
||||
static int eeprom_open0(FAR struct file *filp);
|
||||
static int eeprom_close0(FAR struct file *filp);
|
||||
static ssize_t eeprom_read0(struct file *filp, FAR char *buffer, size_t buflen);
|
||||
static ssize_t eeprom_write0(struct file *filp, FAR const char *buffer, size_t buflen);
|
||||
static off_t eeprom_seek0(FAR struct file *filp, off_t offset, int whence);
|
||||
#if (MAX_EEPROMS > 1)
|
||||
static int eeprom_open1(FAR struct file *filp);
|
||||
static int eeprom_close1(FAR struct file *filp);
|
||||
static ssize_t eeprom_read1(struct file *filp, FAR char *buffer, size_t buflen);
|
||||
static ssize_t eeprom_write1(struct file *filp, FAR const char *buffer, size_t buflen);
|
||||
static off_t eeprom_seek1(FAR struct file *filp, off_t offset, int whence);
|
||||
#endif
|
||||
#if (MAX_EEPROMS > 2)
|
||||
static int eeprom_open2(FAR struct file *filp);
|
||||
static int eeprom_close2(FAR struct file *filp);
|
||||
static ssize_t eeprom_read2(struct file *filp, FAR char *buffer, size_t buflen);
|
||||
static ssize_t eeprom_write2(struct file *filp, FAR const char *buffer, size_t buflen);
|
||||
static off_t eeprom_seek2(FAR struct file *filp, off_t offset, int whence);
|
||||
#endif
|
||||
|
||||
static const struct file_operations eeprom_fops[MAX_EEPROMS] = {{
|
||||
.open = eeprom_open0,
|
||||
.close = eeprom_close0,
|
||||
.read = eeprom_read0,
|
||||
.write = eeprom_write0,
|
||||
.seek = eeprom_seek0,
|
||||
.ioctl = 0,
|
||||
#ifndef CONFIG_DISABLE_POLL
|
||||
.poll = 0
|
||||
#endif
|
||||
}
|
||||
#if (MAX_EEPROMS > 1)
|
||||
,{
|
||||
.open = eeprom_open1,
|
||||
.close = eeprom_close1,
|
||||
.read = eeprom_read1,
|
||||
.write = eeprom_write1,
|
||||
.seek = eeprom_seek1,
|
||||
}
|
||||
#endif
|
||||
#if (MAX_EEPROMS > 2)
|
||||
,{
|
||||
.open = eeprom_open2,
|
||||
.close = eeprom_close2,
|
||||
.read = eeprom_read2,
|
||||
.write = eeprom_write2,
|
||||
.seek = eeprom_seek2,
|
||||
}
|
||||
#endif
|
||||
};
|
||||
|
||||
static FAR struct eeprom_dev_s
|
||||
{
|
||||
struct i2c_dev_s *i2c;
|
||||
uint8_t eeprom_address;
|
||||
uint16_t eeprom_size_bytes;
|
||||
uint16_t eeprom_page_size_bytes;
|
||||
uint16_t eeprom_page_write_time;
|
||||
off_t offset;
|
||||
bool is_open;
|
||||
} eeprom_dev[MAX_EEPROMS];
|
||||
|
||||
static int
|
||||
eeprom_open0(FAR struct file *filp)
|
||||
{
|
||||
/* only allow one open at a time */
|
||||
if (eeprom_dev[0].is_open) {
|
||||
errno = EBUSY;
|
||||
return -EBUSY;
|
||||
}
|
||||
/* reset pointer */
|
||||
//eeprom_dev[0].is_open = true;
|
||||
eeprom_dev[0].offset = 0;
|
||||
return OK;
|
||||
}
|
||||
#if (MAX_EEPROMS > 1)
|
||||
static int
|
||||
eeprom_open1(FAR struct file *filp)
|
||||
{
|
||||
/* only allow one open at a time */
|
||||
if (eeprom_dev[1].is_open) {
|
||||
errno = EBUSY;
|
||||
return -EBUSY;
|
||||
}
|
||||
/* reset pointer */
|
||||
//eeprom_dev[1].is_open = true;
|
||||
eeprom_dev[1].offset = 0;
|
||||
return OK;
|
||||
}
|
||||
#endif
|
||||
#if (MAX_EEPROMS > 2)
|
||||
static int
|
||||
eeprom_open2(FAR struct file *filp)
|
||||
{
|
||||
/* only allow one open at a time */
|
||||
if (eeprom_dev[2].is_open) {
|
||||
errno = EBUSY;
|
||||
return -EBUSY;
|
||||
}
|
||||
/* reset pointer */
|
||||
//eeprom_dev[2].is_open = true;
|
||||
eeprom_dev[2].offset = 0;
|
||||
return OK;
|
||||
}
|
||||
#endif
|
||||
|
||||
static int
|
||||
eeprom_close0(FAR struct file *filp)
|
||||
{
|
||||
eeprom_dev[0].is_open = false;
|
||||
return OK;
|
||||
}
|
||||
#if (MAX_EEPROMS > 1)
|
||||
static int
|
||||
eeprom_close1(FAR struct file *filp)
|
||||
{
|
||||
eeprom_dev[1].is_open = false;
|
||||
return OK;
|
||||
}
|
||||
#endif
|
||||
#if (MAX_EEPROMS > 2)
|
||||
static int
|
||||
eeprom_close2(FAR struct file *filp)
|
||||
{
|
||||
eeprom_dev[2].is_open = false;
|
||||
return OK;
|
||||
}
|
||||
#endif
|
||||
|
||||
static int
|
||||
eeprom_read_internal(int dev, uint16_t len, uint8_t *data)
|
||||
{
|
||||
/* abort if the number of requested bytes exceeds the EEPROM size */
|
||||
if (eeprom_dev[dev].offset + len > eeprom_dev[dev].eeprom_size_bytes)
|
||||
{
|
||||
errno = ENOSPC;
|
||||
return -ENOSPC;
|
||||
}
|
||||
|
||||
/* set device address */
|
||||
I2C_SETADDRESS(eeprom_dev[dev].i2c, eeprom_dev[dev].eeprom_address, 7);
|
||||
|
||||
uint8_t cmd[2] = {0, 0}; /* first (or only) part of address */
|
||||
/* second part of address, omitted if eeprom has 256 bytes or less */
|
||||
int ret = 0;
|
||||
int remaining = len;
|
||||
int readcounts = 0;
|
||||
|
||||
while (remaining > 0)
|
||||
{
|
||||
/* read all requested bytes over potentially multiple pages */
|
||||
//int readlen = (remaining < eeprom_dev[dev].eeprom_page_size_bytes) ? remaining : eeprom_dev[dev].eeprom_page_size_bytes;
|
||||
int read_offset = eeprom_dev[dev].offset + len - remaining;//+ write_counts*eeprom_dev[dev].eeprom_page_size_bytes;
|
||||
/* set read length to page border */
|
||||
int readlen = eeprom_dev[dev].eeprom_page_size_bytes - (read_offset % eeprom_dev[dev].eeprom_page_size_bytes);//(remaining < eeprom_dev[dev].eeprom_page_size_bytes) ? remaining : eeprom_dev[dev].eeprom_page_size_bytes;
|
||||
/* cap read length if not a full page read is needed */
|
||||
if (readlen > remaining) readlen = remaining;
|
||||
|
||||
if (eeprom_dev[dev].eeprom_size_bytes <= 256)
|
||||
{
|
||||
cmd[0] = (read_offset); /* set at first byte */
|
||||
/* 8 bit addresses */
|
||||
ret = I2C_WRITEREAD(eeprom_dev[dev].i2c, cmd, 1, (data+(readcounts*eeprom_dev[dev].eeprom_page_size_bytes)), readlen);
|
||||
}
|
||||
else
|
||||
{
|
||||
/* 16 bit addresses */
|
||||
/* EEPROM: first address high, then address low */
|
||||
cmd[0] = (((uint16_t)read_offset) >> 8);
|
||||
cmd[1] = (((uint8_t)read_offset));
|
||||
ret = I2C_WRITEREAD(eeprom_dev[dev].i2c, cmd, 2, (data+(readcounts*eeprom_dev[dev].eeprom_page_size_bytes)), readlen);
|
||||
}
|
||||
|
||||
/* abort on error */
|
||||
if (ret < 0) break;
|
||||
|
||||
/* handled another chunk */
|
||||
remaining -= readlen;
|
||||
readcounts++;
|
||||
}
|
||||
|
||||
/* use the negated value from I2C_TRANSFER to fill errno */
|
||||
errno = -ret;
|
||||
|
||||
/* return len if data was read, < 0 else */
|
||||
if (ret == OK)
|
||||
eeprom_dev[dev].offset += len;
|
||||
return len;
|
||||
|
||||
/* no data, return negated value from I2C_TRANSFER */
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int
|
||||
eeprom_write_internal(int dev, uint16_t len, const uint8_t *data)
|
||||
{
|
||||
/* abort if the number of requested bytes exceeds the EEPROM size */
|
||||
if (eeprom_dev[dev].offset + len > eeprom_dev[dev].eeprom_size_bytes)
|
||||
{
|
||||
errno = ENOSPC;
|
||||
return -ENOSPC;
|
||||
}
|
||||
|
||||
int ret = 0;
|
||||
int remaining = len;
|
||||
int write_counts = 0;
|
||||
|
||||
uint8_t write_buf[2];
|
||||
|
||||
while (remaining > 0)
|
||||
{
|
||||
/* write all requested bytes over potentially multiple pages */
|
||||
int write_offset = eeprom_dev[dev].offset + len - remaining;//+ write_counts*eeprom_dev[dev].eeprom_page_size_bytes;
|
||||
/* set write length to page border */
|
||||
int writelen = eeprom_dev[dev].eeprom_page_size_bytes - (write_offset % eeprom_dev[dev].eeprom_page_size_bytes);//(remaining < eeprom_dev[dev].eeprom_page_size_bytes) ? remaining : eeprom_dev[dev].eeprom_page_size_bytes;
|
||||
/* cap write length if not a full page write is requested */
|
||||
if (writelen > remaining) writelen = remaining;
|
||||
|
||||
if (eeprom_dev[dev].eeprom_size_bytes <= 256)
|
||||
{
|
||||
write_buf[0] = (write_offset); /* set at first byte */
|
||||
/* 8 bit addresses */
|
||||
|
||||
const uint8_t* data_ptr = (data+(write_offset));
|
||||
|
||||
struct i2c_msg_s msgv_eeprom_write[2] = {
|
||||
{
|
||||
.addr = eeprom_dev[dev].eeprom_address,
|
||||
.flags = I2C_M_NORESTART,
|
||||
.buffer = write_buf,
|
||||
.length = 1
|
||||
},
|
||||
{
|
||||
.addr = eeprom_dev[dev].eeprom_address,
|
||||
.flags = I2C_M_NORESTART,
|
||||
.buffer = (uint8_t*)data_ptr,
|
||||
.length = writelen
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
if ( (ret = I2C_TRANSFER(eeprom_dev[dev].i2c, msgv_eeprom_write, 2)) == OK )
|
||||
{
|
||||
//printf("SUCCESS WRITING EEPROM 8BIT ADDR: %d, bytes: %d\n", ret, writelen);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* 16 bit addresses */
|
||||
/* EEPROM: first address high, then address low */
|
||||
write_buf[0] = (((uint16_t)write_offset) >> 8);
|
||||
write_buf[1] = (((uint8_t)write_offset));
|
||||
|
||||
const uint8_t* data_ptr = data+(write_counts*eeprom_dev[dev].eeprom_page_size_bytes);
|
||||
|
||||
struct i2c_msg_s msgv_eeprom_write[2] = {
|
||||
{
|
||||
.addr = eeprom_dev[dev].eeprom_address,
|
||||
.flags = I2C_M_NORESTART,
|
||||
.buffer = write_buf,
|
||||
.length = 2
|
||||
},
|
||||
{
|
||||
.addr = eeprom_dev[dev].eeprom_address,
|
||||
.flags = I2C_M_NORESTART,
|
||||
.buffer = (uint8_t*)data_ptr,
|
||||
.length = writelen
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
if ( (ret = I2C_TRANSFER(eeprom_dev[dev].i2c, msgv_eeprom_write, 2)) == OK )
|
||||
{
|
||||
//printf("SUCCESS WRITING EEPROM 16BIT ADDR: %d, bytes: %d\n", ret, writelen);
|
||||
}
|
||||
}
|
||||
|
||||
/* abort on error */
|
||||
if (ret < 0) break;
|
||||
|
||||
/* handled another chunk */
|
||||
remaining -= writelen;
|
||||
write_counts++;
|
||||
/* wait for the device to write the page */
|
||||
usleep(eeprom_dev[dev].eeprom_page_write_time);
|
||||
}
|
||||
|
||||
/* use the negated value from I2C_TRANSFER to fill errno */
|
||||
errno = -ret;
|
||||
|
||||
/* return length if data was written, < 0 else */
|
||||
if (ret == OK)
|
||||
eeprom_dev[dev].offset += len;
|
||||
return len;
|
||||
|
||||
/* no data, return negated value from I2C_TRANSFER */
|
||||
return ret;
|
||||
}
|
||||
|
||||
static ssize_t
|
||||
eeprom_read0(struct file *filp, char *buffer, size_t buflen)
|
||||
{
|
||||
return eeprom_read_internal(0, buflen, (uint8_t *)buffer);
|
||||
}
|
||||
#if (MAX_EEPROMS > 1)
|
||||
static ssize_t
|
||||
eeprom_read1(struct file *filp, char *buffer, size_t buflen)
|
||||
{
|
||||
return eeprom_read_internal(1, buflen, (uint8_t *)buffer);
|
||||
}
|
||||
#endif
|
||||
#if (MAX_EEPROMS > 2)
|
||||
static ssize_t
|
||||
eeprom_read2(struct file *filp, char *buffer, size_t buflen)
|
||||
{
|
||||
return eeprom_read_internal(2, buflen, (uint8_t *)buffer);
|
||||
}
|
||||
#endif
|
||||
|
||||
static ssize_t
|
||||
eeprom_write0(struct file *filp, const char *buffer, size_t buflen)
|
||||
{
|
||||
return eeprom_write_internal(0, buflen, (const uint8_t *)buffer);
|
||||
}
|
||||
#if (MAX_EEPROMS > 1)
|
||||
static ssize_t
|
||||
eeprom_write1(struct file *filp, const char *buffer, size_t buflen)
|
||||
{
|
||||
return eeprom_write_internal(1, buflen, (const uint8_t *)buffer);
|
||||
}
|
||||
#endif
|
||||
#if (MAX_EEPROMS > 2)
|
||||
static ssize_t
|
||||
eeprom_write2(struct file *filp, const char *buffer, size_t buflen)
|
||||
{
|
||||
return eeprom_write_internal(2, buflen, (const uint8_t *)buffer);
|
||||
}
|
||||
#endif
|
||||
|
||||
static off_t eeprom_seek0(FAR struct file *filp, off_t offset, int whence)
|
||||
{
|
||||
switch (whence)
|
||||
{
|
||||
case SEEK_SET:
|
||||
if (offset < eeprom_dev[0].eeprom_size_bytes - 1) {
|
||||
eeprom_dev[0].offset = offset;
|
||||
} else {
|
||||
errno = ESPIPE;
|
||||
return -ESPIPE;
|
||||
}
|
||||
break;
|
||||
case SEEK_CUR:
|
||||
if (eeprom_dev[0].offset + offset < eeprom_dev[0].eeprom_size_bytes - 1) {
|
||||
eeprom_dev[0].offset = eeprom_dev[0].offset + offset;
|
||||
} else {
|
||||
errno = ESPIPE;
|
||||
return -ESPIPE;
|
||||
}
|
||||
break;
|
||||
case SEEK_END:
|
||||
errno = ESPIPE;
|
||||
return -ESPIPE;
|
||||
break;
|
||||
}
|
||||
return eeprom_dev[0].offset;
|
||||
}
|
||||
#if (MAX_EEPROMS > 1)
|
||||
static off_t eeprom_seek1(FAR struct file *filp, off_t offset, int whence)
|
||||
{
|
||||
switch (whence)
|
||||
{
|
||||
case SEEK_SET:
|
||||
if (offset < eeprom_dev[1].eeprom_size_bytes - 1) {
|
||||
eeprom_dev[1].offset = offset;
|
||||
} else {
|
||||
errno = ESPIPE;
|
||||
return -ESPIPE;
|
||||
}
|
||||
break;
|
||||
case SEEK_CUR:
|
||||
if (eeprom_dev[1].offset + offset < eeprom_dev[1].eeprom_size_bytes - 1) {
|
||||
eeprom_dev[1].offset = eeprom_dev[1].offset + offset;
|
||||
} else {
|
||||
errno = ESPIPE;
|
||||
return -ESPIPE;
|
||||
}
|
||||
break;
|
||||
case SEEK_END:
|
||||
errno = ESPIPE;
|
||||
return -ESPIPE;
|
||||
break;
|
||||
}
|
||||
return eeprom_dev[1].offset;
|
||||
}
|
||||
#endif
|
||||
#if (MAX_EEPROMS > 2)
|
||||
static off_t eeprom_seek2(FAR struct file *filp, off_t offset, int whence)
|
||||
{
|
||||
switch (whence)
|
||||
{
|
||||
case SEEK_SET:
|
||||
if (offset < eeprom_dev[2].eeprom_size_bytes - 1) {
|
||||
eeprom_dev[2].offset = offset;
|
||||
} else {
|
||||
errno = ESPIPE;
|
||||
return -ESPIPE;
|
||||
}
|
||||
break;
|
||||
case SEEK_CUR:
|
||||
if (eeprom_dev[2].offset + offset < eeprom_dev[2].eeprom_size_bytes - 1) {
|
||||
eeprom_dev[2].offset = eeprom_dev[2].offset + offset;
|
||||
} else {
|
||||
errno = ESPIPE;
|
||||
return -ESPIPE;
|
||||
}
|
||||
break;
|
||||
case SEEK_END:
|
||||
errno = ESPIPE;
|
||||
return -ESPIPE;
|
||||
break;
|
||||
}
|
||||
return eeprom_dev[2].offset;
|
||||
}
|
||||
#endif
|
||||
|
||||
int
|
||||
eeprom_attach(struct i2c_dev_s *i2c, uint8_t device_address, uint16_t total_size_bytes, uint16_t page_size_bytes, uint16_t page_write_time_us, const char* device_name, uint8_t fail_if_missing)
|
||||
{
|
||||
static int eeprom_dev_counter = 0;
|
||||
eeprom_dev[eeprom_dev_counter].i2c = i2c;
|
||||
eeprom_dev[eeprom_dev_counter].eeprom_address = device_address;
|
||||
eeprom_dev[eeprom_dev_counter].eeprom_size_bytes = total_size_bytes;
|
||||
eeprom_dev[eeprom_dev_counter].eeprom_page_size_bytes = page_size_bytes;
|
||||
eeprom_dev[eeprom_dev_counter].eeprom_page_write_time = page_write_time_us;
|
||||
eeprom_dev[eeprom_dev_counter].offset = 0;
|
||||
eeprom_dev[eeprom_dev_counter].is_open = false;
|
||||
|
||||
int ret;
|
||||
|
||||
if (fail_if_missing) {
|
||||
/* read first value */
|
||||
uint8_t read_test;
|
||||
ret = (eeprom_read_internal(eeprom_dev_counter, 1, &read_test) == 1) ? OK : ERROR;
|
||||
} else {
|
||||
ret = OK;
|
||||
}
|
||||
|
||||
/* make ourselves available */
|
||||
if (ret == OK)
|
||||
{
|
||||
register_driver(device_name, &(eeprom_fops[eeprom_dev_counter]), 0666, NULL);
|
||||
eeprom_dev_counter++;
|
||||
}
|
||||
|
||||
/* Return 0 for device found, error number else */
|
||||
return ret;
|
||||
}
|
||||
Reference in New Issue
Block a user