uint8_t
spiflash_read_status(struct spiflash_dev *dev)
{
uint8_t val;
spiflash_cs_activate(dev);
hal_spi_tx_val(dev->spi_num, SPIFLASH_READ_STATUS_REGISTER);
val = hal_spi_tx_val(dev->spi_num, 0xFF);
spiflash_cs_deactivate(dev);
return val;
}
/**
* Read multiple bytes starting from specified register over SPI
*
* @param The sensor interface
* @param The register address start reading from
* @param Pointer to where the register value should be written
* @param Number of bytes to read
*
* @return 0 on success, non-zero on failure
*/
int
adxl345_spi_readlen(struct sensor_itf *itf, uint8_t reg, uint8_t *buffer,
uint8_t len)
{
int i;
uint16_t retval;
int rc = 0;
/* Select the device */
hal_gpio_write(itf->si_cs_pin, 0);
/* Send the address */
retval = hal_spi_tx_val(itf->si_num, reg | ADXL345_SPI_READ_CMD_BIT
| ADXL345_SPI_MULTIBYTE_CMD_BIT);
if (retval == 0xFFFF) {
rc = SYS_EINVAL;
ADXL345_LOG(ERROR, "SPI_%u register write failed addr:0x%02X\n",
itf->si_num, reg);
STATS_INC(g_adxl345stats, read_errors);
goto err;
}
for (i = 0; i < len; i++) {
/* Read data */
retval = hal_spi_tx_val(itf->si_num, 0);
if (retval == 0xFFFF) {
rc = SYS_EINVAL;
ADXL345_LOG(ERROR, "SPI_%u read failed addr:0x%02X\n",
itf->si_num, reg);
STATS_INC(g_adxl345stats, read_errors);
goto err;
}
buffer[i] = retval;
}
err:
/* De-select the device */
hal_gpio_write(itf->si_cs_pin, 1);
return rc;
}
int
spiflash_write_enable(struct spiflash_dev *dev)
{
spiflash_cs_activate(dev);
hal_spi_tx_val(dev->spi_num, SPIFLASH_WRITE_ENABLE);
spiflash_cs_deactivate(dev);
return 0;
}
/**
* Reads a single byte from the specified register using SPI
*
* @param The register address to read from
* @param Pointer to where the register value should be written
*
* @return 0 on success, non-zero error on failure.
*/
int
adxl345_spi_read8(struct sensor_itf *itf, uint8_t reg, uint8_t *value)
{
uint16_t retval;
int rc = 0;
/* Select the device */
hal_gpio_write(itf->si_cs_pin, 0);
/* Send the address */
retval = hal_spi_tx_val(itf->si_num, reg | ADXL345_SPI_READ_CMD_BIT);
if (retval == 0xFFFF) {
rc = SYS_EINVAL;
ADXL345_LOG(ERROR, "SPI_%u register write failed addr:0x%02X\n",
itf->si_num, reg);
STATS_INC(g_adxl345stats, read_errors);
goto err;
}
/* Read data */
retval = hal_spi_tx_val(itf->si_num, 0);
if (retval == 0xFFFF) {
rc = SYS_EINVAL;
ADXL345_LOG(ERROR, "SPI_%u read failed addr:0x%02X\n",
itf->si_num, reg);
STATS_INC(g_adxl345stats, read_errors);
goto err;
}
*value = retval;
err:
/* De-select the device */
hal_gpio_write(itf->si_cs_pin, 1);
return rc;
}
void
task1_handler(void *arg)
{
int i;
int rc;
uint16_t rxval;
uint8_t last_val;
uint8_t spi_nb_cntr;
uint8_t spi_b_cntr;
/* Set the led pin for the E407 devboard */
g_led_pin = LED_BLINK_PIN;
hal_gpio_init_out(g_led_pin, 1);
/* Use SS pin for testing */
hal_gpio_init_out(SPI_SS_PIN, 1);
sblinky_spi_cfg(0);
hal_spi_set_txrx_cb(0, NULL, NULL);
hal_spi_enable(0);
/*
* Send some bytes in a non-blocking manner to SPI using tx val. The
* slave should send back 0x77.
*/
g_spi_tx_buf[0] = 0xde;
g_spi_tx_buf[1] = 0xad;
g_spi_tx_buf[2] = 0xbe;
g_spi_tx_buf[3] = 0xef;
hal_gpio_write(SPI_SS_PIN, 0);
for (i = 0; i < 4; ++i) {
rxval = hal_spi_tx_val(0, g_spi_tx_buf[i]);
assert(rxval == 0x77);
g_spi_rx_buf[i] = (uint8_t)rxval;
}
hal_gpio_write(SPI_SS_PIN, 1);
++g_spi_xfr_num;
/* Set up the callback to use when non-blocking API used */
hal_spi_disable(0);
spi_cb_arg = &spi_cb_obj;
spi_cb_obj.txlen = 32;
hal_spi_set_txrx_cb(0, sblinky_spi_irqm_handler, spi_cb_arg);
hal_spi_enable(0);
spi_nb_cntr = 0;
spi_b_cntr = 0;
while (1) {
/* Wait one second */
os_time_delay(OS_TICKS_PER_SEC);
/* Toggle the LED */
hal_gpio_toggle(g_led_pin);
/* Get random length to send */
g_last_tx_len = spi_cb_obj.txlen;
spi_cb_obj.txlen = (rand() & 0x1F) + 1;
memcpy(g_spi_last_tx_buf, g_spi_tx_buf, g_last_tx_len);
last_val = g_spi_last_tx_buf[g_last_tx_len - 1];
for (i= 0; i < spi_cb_obj.txlen; ++i) {
g_spi_tx_buf[i] = (uint8_t)(last_val + i);
}
if (g_spi_xfr_num & 1) {
/* Send non-blocking */
++spi_nb_cntr;
assert(hal_gpio_read(SPI_SS_PIN) == 1);
hal_gpio_write(SPI_SS_PIN, 0);
#if 0
if (spi_nb_cntr == 7) {
g_spi_null_rx = 1;
rc = hal_spi_txrx_noblock(0, g_spi_tx_buf, NULL, 32);
} else {
g_spi_null_rx = 0;
rc = hal_spi_txrx_noblock(0, g_spi_tx_buf, g_spi_rx_buf, 32);
}
assert(!rc);
#else
g_spi_null_rx = 0;
rc = hal_spi_txrx_noblock(0, g_spi_tx_buf, g_spi_rx_buf,
spi_cb_obj.txlen);
assert(!rc);
console_printf("a transmitted: ");
for (i = 0; i < spi_cb_obj.txlen; i++) {
console_printf("%2x ", g_spi_tx_buf[i]);
}
console_printf("\n");
console_printf("received: ");
for (i = 0; i < spi_cb_obj.txlen; i++) {
console_printf("%2x ", g_spi_rx_buf[i]);
}
console_printf("\n");
#endif
} else {
/* Send blocking */
++spi_b_cntr;
assert(hal_gpio_read(SPI_SS_PIN) == 1);
hal_gpio_write(SPI_SS_PIN, 0);
#if 0
if (spi_b_cntr == 7) {
g_spi_null_rx = 1;
rc = hal_spi_txrx(0, g_spi_tx_buf, NULL, 32);
spi_b_cntr = 0;
} else {
g_spi_null_rx = 0;
rc = hal_spi_txrx(0, g_spi_tx_buf, g_spi_rx_buf, 32);
}
assert(!rc);
hal_gpio_write(SPI_SS_PIN, 1);
spitest_validate_last(spi_cb_obj.txlen);
#else
rc = hal_spi_txrx(0, g_spi_tx_buf, g_spi_rx_buf, spi_cb_obj.txlen);
assert(!rc);
hal_gpio_write(SPI_SS_PIN, 1);
console_printf("b transmitted: ");
for (i = 0; i < spi_cb_obj.txlen; i++) {
console_printf("%2x ", g_spi_tx_buf[i]);
}
console_printf("\n");
console_printf("received: ");
for (i = 0; i < spi_cb_obj.txlen; i++) {
console_printf("%2x ", g_spi_rx_buf[i]);
}
console_printf("\n");
spitest_validate_last(spi_cb_obj.txlen);
++g_spi_xfr_num;
#endif
}
}
}
/**
* Writes a single byte to the specified register using i2c
*
* @param The sensor interface
* @param The register address to write to
* @param The value to write
*
* @return 0 on success, non-zero error on failure.
*/
int
lis2dw12_i2c_write8(struct sensor_itf *itf, uint8_t reg, uint8_t value)
{
int rc;
uint8_t payload[2] = { reg, value };
struct hal_i2c_master_data data_struct = {
.address = itf->si_addr,
.len = 2,
.buffer = payload
};
rc = hal_i2c_master_write(itf->si_num, &data_struct,
OS_TICKS_PER_SEC / 10, 1);
if (rc) {
LIS2DW12_ERR("Failed to write to 0x%02X:0x%02X with value 0x%02X\n",
itf->si_addr, reg, value);
STATS_INC(g_lis2dw12stats, read_errors);
}
return rc;
}
/**
* Read multiple bytes starting from specified register over i2c
*
* @param The sensor interface
* @param The register address start reading from
* @param Pointer to where the register value should be written
* @param Number of bytes to read
*
* @return 0 on success, non-zero error on failure.
*/
int
lis2dw12_i2c_readlen(struct sensor_itf *itf, uint8_t reg, uint8_t *buffer, uint8_t len)
{
int rc;
struct hal_i2c_master_data data_struct = {
.address = itf->si_addr,
.len = 1,
.buffer = ®
};
/* Register write */
rc = hal_i2c_master_write(itf->si_num, &data_struct,
OS_TICKS_PER_SEC / 10, 1);
if (rc) {
LIS2DW12_ERR("I2C access failed at address 0x%02X\n", itf->si_addr);
STATS_INC(g_lis2dw12stats, write_errors);
return rc;
}
/* Read data */
data_struct.len = len;
data_struct.buffer = buffer;
rc = hal_i2c_master_read(itf->si_num, &data_struct,
OS_TICKS_PER_SEC / 10, 1);
if (rc) {
LIS2DW12_ERR("Failed to read from 0x%02X:0x%02X\n", itf->si_addr, reg);
STATS_INC(g_lis2dw12stats, read_errors);
}
return rc;
}
/**
* Writes a single byte to the specified register using SPI
*
* @param The sensor interface
* @param The register address to write to
* @param The value to write
*
* @return 0 on success, non-zero error on failure.
*/
int
lis2dw12_spi_write8(struct sensor_itf *itf, uint8_t reg, uint8_t value)
{
int rc;
/* Select the device */
hal_gpio_write(itf->si_cs_pin, 0);
/* Send the address */
rc = hal_spi_tx_val(itf->si_num, reg & ~LIS2DW12_SPI_READ_CMD_BIT);
if (rc == 0xFFFF) {
rc = SYS_EINVAL;
LIS2DW12_ERR("SPI_%u register write failed addr:0x%02X\n",
itf->si_num, reg);
STATS_INC(g_lis2dw12stats, write_errors);
goto err;
}
/* Read data */
rc = hal_spi_tx_val(itf->si_num, value);
if (rc == 0xFFFF) {
rc = SYS_EINVAL;
LIS2DW12_ERR("SPI_%u write failed addr:0x%02X:0x%02X\n",
itf->si_num, reg);
STATS_INC(g_lis2dw12stats, write_errors);
goto err;
}
rc = 0;
err:
/* De-select the device */
hal_gpio_write(itf->si_cs_pin, 1);
return rc;
}
