patrick/zephyr
1
0
Fork 0
Code Issues Pull requests Actions 7 Packages Projects Releases Wiki Activity

samples/drivers: Switch Fujistu FRAM sample to new SPI API

Browse source 
Replacing legacy API calls by news ones.

Signed-off-by: Tomasz Bursztyka <tomasz.bursztyka@linux.intel.com>
This commit is contained in:
Tomasz Bursztyka 2018-02-01 11:21:48 +01:00 committed by Carles Cufí
parent 595340ab8a
commit 308f4df91d
2 changed files with 76 additions and 60 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
samples/drivers/spi_fujitsu_fram/prj.conf
View file

@ -2,7 +2,6 @@ CONFIG_STDOUT_CONSOLE=y
CONFIG_PRINTK=y CONFIG_PRINTK=y
CONFIG_SPI=y CONFIG_SPI=y
CONFIG_SPI_LEGACY_API=y
CONFIG_GPIO=y CONFIG_GPIO=y
CONFIG_SPI_CS_GPIO=y CONFIG_SPI_CS_GPIO=y
CONFIG_SPI_1_CS_GPIO_PORT="GPIO_0" CONFIG_SPI_1_CS_GPIO_PORT="GPIO_0"

135
samples/drivers/spi_fujitsu_fram/src/main.c
View file

@ -15,67 +15,102 @@
*/ */
#define MB85RS64V_MANUFACTURER_ID_CMD 0x9f #define MB85RS64V_MANUFACTURER_ID_CMD 0x9f
#define MB85RS64V_WRITE_ENABLE_CMD 0x06
#define MB85RS64V_READ_CMD 0x03
#define MB85RS64V_WRITE_CMD 0x02
#define MAX_USER_DATA_LENGTH 1024 #define MAX_USER_DATA_LENGTH 1024
static u8_t spi_buffer[MAX_USER_DATA_LENGTH + 3];
static u8_t data[MAX_USER_DATA_LENGTH], cmp_data[MAX_USER_DATA_LENGTH]; static u8_t data[MAX_USER_DATA_LENGTH], cmp_data[MAX_USER_DATA_LENGTH];
static int mb85rs64v_read_id(struct device *dev) static int mb85rs64v_access(struct device *spi, struct spi_config *spi_cfg,
u8_t cmd, u16_t addr, void *data, size_t len)
{ {
u8_t access[3];
struct spi_buf bufs[] = {
{
.buf = access,
},
{
.buf = data,
.len = len
}
};
struct spi_buf_set tx = {
.buffers = bufs
};
access[0] = cmd;
if (cmd == MB85RS64V_WRITE_CMD || cmd == MB85RS64V_READ_CMD) {
access[1] = (addr >> 8) & 0xFF;
access[2] = addr & 0xFF;
bufs[0].len = 3;
tx.count = 2;
if (cmd == MB85RS64V_READ_CMD) {
struct spi_buf_set rx = {
.buffers = bufs,
.count = 2
};
return spi_transceive(spi, spi_cfg, &tx, &rx);
}
} else {
tx.count = 1;
}
return spi_write(spi, spi_cfg, &tx);
}
static int mb85rs64v_read_id(struct device *spi, struct spi_config *spi_cfg)
{
u8_t id[4];
int err; int err;
spi_buffer[0] = MB85RS64V_MANUFACTURER_ID_CMD; err = mb85rs64v_access(spi, spi_cfg,
MB85RS64V_MANUFACTURER_ID_CMD, 0, &id, 4);
err = spi_transceive(dev, spi_buffer, 5, spi_buffer, 5);
if (err) { if (err) {
printk("Error during ID read\n"); printk("Error during ID read\n");
return -EIO; return -EIO;
} }
if (spi_buffer[1] != 0x04) { if (id[0] != 0x04) {
return -EIO; return -EIO;
} }
if (spi_buffer[2] != 0x7f) { if (id[1] != 0x7f) {
return -EIO; return -EIO;
} }
if (spi_buffer[3] != 0x03) { if (id[2] != 0x03) {
return -EIO; return -EIO;
} }
if (spi_buffer[4] != 0x02) { if (id[3] != 0x02) {
return -EIO; return -EIO;
} }
return 0; return 0;
} }
static int write_bytes(struct device *dev, u16_t addr, static int write_bytes(struct device *spi, struct spi_config *spi_cfg,
u8_t *data, u32_t num_bytes) u16_t addr, u8_t *data, u32_t num_bytes)
{ {
int err; int err;
/* write protect disable cmd */
spi_buffer[0] = 0x06;
/* disable write protect */ /* disable write protect */
err = spi_write(dev, spi_buffer, 1); err = mb85rs64v_access(spi, spi_cfg,
MB85RS64V_WRITE_ENABLE_CMD, 0, NULL, 0);
if (err) { if (err) {
printk("unable to disable write protect\n"); printk("unable to disable write protect\n");
return -EIO; return -EIO;
} }
/* write cmd */ /* write cmd */
spi_buffer[0] = 0x02; err = mb85rs64v_access(spi, spi_cfg,
spi_buffer[1] = (addr >> 8) & 0xFF; MB85RS64V_WRITE_CMD, addr, data, num_bytes);
spi_buffer[2] = addr & 0xFF;
for (u32_t i = 0; i < num_bytes; i++) {
spi_buffer[i + 3] = data[i];
}
err = spi_write(dev, spi_buffer, num_bytes + 3);
if (err) { if (err) {
printk("Error during SPI write\n"); printk("Error during SPI write\n");
return -EIO; return -EIO;
@ -84,59 +119,41 @@ static int write_bytes(struct device *dev, u16_t addr,
return 0; return 0;
} }
static int read_bytes(struct device *dev, u16_t addr, static int read_bytes(struct device *spi, struct spi_config *spi_cfg,
u8_t *data, u32_t num_bytes) u16_t addr, u8_t *data, u32_t num_bytes)
{ {
int err; int err;
/* read cmd */ /* read cmd */
spi_buffer[0] = 0x03; err = mb85rs64v_access(spi, spi_cfg,
spi_buffer[1] = (addr >> 8) & 0xFF; MB85RS64V_READ_CMD, addr, data, num_bytes);
spi_buffer[2] = addr & 0xFF;
err = spi_transceive(dev, spi_buffer, num_bytes + 3, spi_buffer,
num_bytes + 3);
if (err) { if (err) {
printk("Error during SPI read\n"); printk("Error during SPI read\n");
return -EIO; return -EIO;
} }
for (u32_t i = 0; i < num_bytes; i++) {
data[i] = spi_buffer[i + 3];
}
return 0; return 0;
} }
void main(void) void main(void)
{ {
struct spi_config config = { 0 }; struct device *spi;
struct device *spi_mst_1 = device_get_binding(CONFIG_SPI_1_NAME); struct spi_config spi_cfg;
int err; int err;
printk("fujitsu FRAM example application\n"); printk("fujitsu FRAM example application\n");
if (!spi_mst_1) { spi = device_get_binding(CONFIG_SPI_1_NAME);
if (!spi) {
printk("Could not find SPI driver\n"); printk("Could not find SPI driver\n");
return; return;
} }
config.config = SPI_WORD(8); spi_cfg.operation = SPI_WORD_SET(8);
config.max_sys_freq = 256; spi_cfg.frequency = 256000;
err = spi_configure(spi_mst_1, &config);
if (err) {
printk("SPI configuration failed\n");
return;
}
err = spi_slave_select(spi_mst_1, 2); err = mb85rs64v_read_id(spi, &spi_cfg);
if (err) {
printk("SPI slave select failed\n");
return;
}
err = mb85rs64v_read_id(spi_mst_1);
if (err) { if (err) {
printk("Could not verify FRAM ID\n"); printk("Could not verify FRAM ID\n");
return; return;
@ -144,7 +161,7 @@ void main(void)
/* Do one-byte read/write */ /* Do one-byte read/write */
data[0] = 0xAE; data[0] = 0xAE;
err = write_bytes(spi_mst_1, 0x00, data, 1); err = write_bytes(spi, &spi_cfg, 0x00, data, 1);
if (err) { if (err) {
printk("Error writing to FRAM! errro code (%d)\n", err); printk("Error writing to FRAM! errro code (%d)\n", err);
return; return;
@ -153,7 +170,7 @@ void main(void)
} }
data[0] = 0x86; data[0] = 0x86;
err = write_bytes(spi_mst_1, 0x01, data, 1); err = write_bytes(spi, &spi_cfg, 0x01, data, 1);
if (err) { if (err) {
printk("Error writing to FRAM! error code (%d)\n", err); printk("Error writing to FRAM! error code (%d)\n", err);
return; return;
@ -162,7 +179,7 @@ void main(void)
} }
data[0] = 0x00; data[0] = 0x00;
err = read_bytes(spi_mst_1, 0x00, data, 1); err = read_bytes(spi, &spi_cfg, 0x00, data, 1);
if (err) { if (err) {
printk("Error reading from FRAM! error code (%d)\n", err); printk("Error reading from FRAM! error code (%d)\n", err);
return; return;
@ -171,7 +188,7 @@ void main(void)
} }
data[0] = 0x00; data[0] = 0x00;
err = read_bytes(spi_mst_1, 0x01, data, 1); err = read_bytes(spi, &spi_cfg, 0x01, data, 1);
if (err) { if (err) {
printk("Error reading from FRAM! error code (%d)\n", err); printk("Error reading from FRAM! error code (%d)\n", err);
return; return;
@ -187,7 +204,7 @@ void main(void)
} }
/* write them to the FRAM */ /* write them to the FRAM */
err = write_bytes(spi_mst_1, 0x00, cmp_data, sizeof(cmp_data)); err = write_bytes(spi, &spi_cfg, 0x00, cmp_data, sizeof(cmp_data));
if (err) { if (err) {
printk("Error writing to FRAM! error code (%d)\n", err); printk("Error writing to FRAM! error code (%d)\n", err);
return; return;
@ -196,7 +213,7 @@ void main(void)
(u32_t) sizeof(cmp_data)); (u32_t) sizeof(cmp_data));
} }
err = read_bytes(spi_mst_1, 0x00, data, sizeof(data)); err = read_bytes(spi, &spi_cfg, 0x00, data, sizeof(data));
if (err) { if (err) {
printk("Error reading from FRAM! error code (%d)\n", err); printk("Error reading from FRAM! error code (%d)\n", err);
return; return;