/*
* Bytes start with START bit (0) followed by 8 data bits and then the
* STOP bit (1). STOP bit should be configurable. Data bits are sent LSB first.
*/
static void
uart_bitbang_tx_timer(void *arg)
{
struct uart_bitbang *ub = (struct uart_bitbang *)arg;
uint32_t next = 0;
int data;
if (!ub->ub_txing || ub->ub_tx.bits > 9) {
if (ub->ub_tx.bits > 9) {
if (ub->ub_tx_done) {
ub->ub_tx_done(ub->ub_func_arg);
}
}
data = ub->ub_tx_func(ub->ub_func_arg);
if (data < 0) {
ub->ub_txing = 0;
return;
} else {
ub->ub_tx.byte = data;
}
/*
* Start bit
*/
hal_gpio_write(ub->ub_tx.pin, 0);
ub->ub_tx.start = cputime_get32();
next = ub->ub_tx.start + ub->ub_bittime;
ub->ub_txing = 1;
ub->ub_tx.bits = 0;
} else {
if (ub->ub_tx.bits++ < 8) {
hal_gpio_write(ub->ub_tx.pin, ub->ub_tx.byte & 0x01);
ub->ub_tx.byte = ub->ub_tx.byte >> 1;
next = ub->ub_tx.start + (ub->ub_bittime * (ub->ub_tx.bits + 1));
} else {
static sint8
nm_spi_rw(uint8 *pu8Mosi, uint8 *pu8Miso, uint16 u16Sz)
{
int rc = M2M_SUCCESS;
uint8_t tx = 0;
uint8_t rx;
/* chip select */
hal_gpio_write(WINC1500_SPI_SSN, 0);
while (u16Sz) {
if (pu8Mosi) {
tx = *pu8Mosi;
pu8Mosi++;
}
//rx = hal_spi_tx_val(BSP_WINC1500_SPI_PORT, tx);
rc = hal_spi_txrx(BSP_WINC1500_SPI_PORT, &tx, &rx, 1);
if (rc != 0) {
rc = M2M_ERR_BUS_FAIL;
break;
}
if (pu8Miso) {
*pu8Miso = rx;
pu8Miso++;
}
u16Sz--;
}
/* chip deselect */
hal_gpio_write(WINC1500_SPI_SSN, 1);
return rc;
}
void
SX1276SetAntSw(uint8_t rxTx)
{
// 1: TX, 0: RX
if (rxTx != 0) {
hal_gpio_write(SX1276_RXTX, 1);
} else {
hal_gpio_write(SX1276_RXTX, 0);
}
}
/**
* gpio toggle
*
* Toggles the specified pin
*
* @param pin Pin number to toggle
*
* @return current pin state int 0: low, 1: high
*/
int
hal_gpio_toggle(int pin)
{
int pin_state = (hal_gpio_read(pin) == 0);
hal_gpio_write(pin, pin_state);
return pin_state;
}
void
sblinky_spi_irqm_handler(void *arg, int len)
{
int i;
struct sblinky_spi_cb_arg *cb;
hal_gpio_write(SPI_SS_PIN, 1);
assert(arg == spi_cb_arg);
if (spi_cb_arg) {
cb = (struct sblinky_spi_cb_arg *)arg;
assert(len == cb->txlen);
++cb->transfers;
}
/* Make sure we get back the data we expect! */
if (g_spi_xfr_num == 1) {
/* The first time we expect entire buffer to be filled with 0x88 */
for (i = 0; i < len; ++i) {
if (g_spi_rx_buf[i] != 0x88) {
assert(0);
}
}
/* copy current tx buf to last */
memcpy(g_spi_last_tx_buf, g_spi_tx_buf, len);
} else {
/* Check that we received what we last sent */
spitest_validate_last(len);
}
++g_spi_xfr_num;
}
int
hal_gpio_init_out(int pin, int val)
{
if (pin >= HAL_GPIO_NUM_PINS) {
return -1;
}
hal_gpio[pin].dir = OUTPUT;
hal_gpio_write(pin,val);
return 0;
}
/**
* 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;
}
/**
* 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;
}
int
bq24040_disable(struct bq24040 *bq24040)
{
/* Don't disable if already disabled */
if (!bq24040->b_is_enabled) {
return 0;
}
if (bq24040->b_cfg.bc_ts_pin->bp_pin_num != -1) {
hal_gpio_write(bq24040->b_cfg.bc_ts_pin->bp_pin_num, 0);
bq24040->b_is_enabled = false;
return 0;
}
return SYS_EINVAL;
}
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
}
}
}
void
hal_gpio_clear(int pin)
{
hal_gpio_write(pin, 0);
}
void
hal_gpio_set(int pin)
{
hal_gpio_write(pin, 1);
}
/**
* 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;
}
static inline void
spiflash_cs_deactivate(struct spiflash_dev *dev)
{
hal_gpio_write(dev->ss_pin, 1);
}
