void init(void) {
/* Setup GPIO ports */
/* *_LIMIT# on PB2, input and external interrupt */
/* NOP, DDRB already contains "0" for input mode */
MCUCR |= _BV(ISC00);
/* *_DIR on PB1, output */
DDRB = _BV(PORTB1);
/* *_STEP on PA7, output */
DDRA = _BV(PORTA7);
/* MOSI, MISO and SCK configured by SPI */
spi_configure(SPI_INT_ENABLE, SPI_OFF, NULL, SPI_SLAVE, NULL, SPI_PHASE_LEADING, NULL);
spi_hook = SPI_hook;
/* CS_STEP# on PA3, input and pin change interrupt */
/* NOP, DDRA already contains "0" for input mode */
PCMSK0 = _BV(PCINT3);
GIFR |= _BV(INTF0) | _BV(PCIF0); /* Avoid spurious interrupts on startup */
GIMSK |= _BV(INT0) | _BV(PCIE0);
/* INT# on PA2, output, open-collector */
/* NOP, DDRA already contains "0" for High-Z and PORTA already contains "0" for open-drain */
/* Initialize state */
NewCommand = false;
LimitInvert = true;
BufferSize = 0;
/* And off we go */
sei();
}
void main(void)
{
struct spi_config config = { 0 };
struct device *spi_mst_0 = device_get_binding("SPI_0");
uint8_t id;
int err;
printk("SPI Example application\n");
if (!spi_mst_0)
return;
config.config = SPI_MODE_CPOL | SPI_MODE_CPHA | SPI_WORD(16);
config.max_sys_freq = 256;
err = spi_configure(spi_mst_0, &config);
if (err) {
printk("Could not configure SPI device\n");
return;
}
err = spi_slave_select(spi_mst_0, 1);
if (err) {
printk("Could not select SPI slave\n");
return;
}
id = lsm9ds0_read_whoami_g(spi_mst_0);
printk("LSM9DS0 Who Am I: 0x%x\n", id);
}
static int
tmp121temp_match(device_t parent, cfdata_t cf, void *aux)
{
struct spi_attach_args *sa = aux;
/* configure for 10MHz */
if (spi_configure(sa->sa_handle, SPI_MODE_0, 1000000))
return 0;
return 1;
}
static int
m25p_match(device_t parent, cfdata_t cf, void *aux)
{
struct spi_attach_args *sa = aux;
/* configure for 20MHz, which is the max for normal reads */
if (spi_configure(sa->sa_handle, SPI_MODE_0, 20000000))
return 0;
return 1;
}
static int ti_adc108s102_read(struct device *dev,
struct adc_seq_table *seq_table)
{
struct ti_adc108s102_config *config = dev->config->config_info;
struct ti_adc108s102_data *adc = dev->driver_data;
struct spi_config spi_conf;
uint32_t data[2] = {0, 0};
struct nano_timer timer;
int ret = 0;
int32_t delay;
spi_conf.config = config->spi_config_flags;
spi_conf.max_sys_freq = config->spi_freq;
nano_timer_init(&timer, data);
if (spi_configure(adc->spi, &spi_conf)) {
return -EIO;
}
if (spi_slave_select(adc->spi, config->spi_slave)) {
return -EIO;
}
/* Resetting all internal channel data */
memset(adc->chans, 0, ADC108S102_CHANNELS_SIZE);
if (_verify_entries(seq_table) == 0) {
return -EINVAL;
}
adc->seq_table = seq_table;
/* Sampling */
while (1) {
delay = _ti_adc108s102_prepare(dev);
if (delay == ADC108S102_DONE) {
break;
}
nano_timer_start(&timer, delay);
nano_task_timer_test(&timer, TICKS_UNLIMITED);
ret = _ti_adc108s102_sampling(dev);
if (ret != 0) {
break;
}
_ti_adc108s102_handle_result(dev);
}
return ret;
}
static int
oj6sh_match(device_t parent, cfdata_t match, void *aux)
{
struct spi_attach_args *sa = aux;
if (strcmp(match->cf_name, "oj6sh"))
return 0;
if (spi_configure(sa->sa_handle, SPI_MODE_0, 2500000))
return 0;
return 2;
}
static int bt_spi_open(void)
{
/* Configure RST pin and hold BLE in Reset */
gpio_pin_configure(rst_dev, GPIO_RESET_PIN,
GPIO_DIR_OUT | GPIO_PUD_PULL_UP);
gpio_pin_write(rst_dev, GPIO_RESET_PIN, 0);
spi_configure(spi_dev, &spi_conf);
#if defined(CONFIG_BLUETOOTH_SPI_BLUENRG)
/* Configure the CS (Chip Select) pin */
gpio_pin_configure(cs_dev, GPIO_CS_PIN,
GPIO_DIR_OUT | GPIO_PUD_PULL_UP);
gpio_pin_write(cs_dev, GPIO_CS_PIN, 1);
#endif /* CONFIG_BLUETOOTH_SPI_BLUENRG */
/* Configure IRQ pin and the IRQ call-back/handler */
gpio_pin_configure(irq_dev, GPIO_IRQ_PIN,
GPIO_DIR_IN | GPIO_INT |
GPIO_INT_EDGE | GPIO_INT_ACTIVE_HIGH);
gpio_init_callback(&gpio_cb, bt_spi_isr, BIT(GPIO_IRQ_PIN));
if (gpio_add_callback(irq_dev, &gpio_cb)) {
return -EINVAL;
}
if (gpio_pin_enable_callback(irq_dev, GPIO_IRQ_PIN)) {
return -EINVAL;
}
/* Start RX thread */
k_thread_spawn(rx_stack, sizeof(rx_stack),
(k_thread_entry_t)bt_spi_rx_thread,
NULL, NULL, NULL, K_PRIO_COOP(7), 0, K_NO_WAIT);
/* Take BLE out of reset */
gpio_pin_write(rst_dev, GPIO_RESET_PIN, 1);
/* Device will let us know when it's ready */
k_sem_take(&sem_initialised, K_FOREVER);
return 0;
}
int main(void)
{
struct spi_config config = { 0 };
struct device *spi_mst_0 = device_get_binding("SPI_0");
uint8_t manufacturer, device_id;
int err;
printk("SPI Example application\n");
if (!spi_mst_0)
return -EIO;
config.config = SPI_MODE_CPOL | SPI_MODE_CPHA | SPI_WORD(8);
config.max_sys_freq = 256;
err = spi_configure(spi_mst_0, &config);
if (err) {
printk("Could not configure SPI device\n");
return -EIO;
}
err = spi_slave_select(spi_mst_0, 1);
if (err) {
printk("Could not select SPI slave\n");
return -EIO;
}
err = w25q80bl_read_id(spi_mst_0, &manufacturer, &device_id);
if (err) {
printk("Could not get Manufacturer and Device ID from SPI Flash\n");
return -EIO;
}
printk("SPI Flash Manufacturer %x Device Id %x\n", manufacturer,
device_id);
return 0;
}
static int bmi160_transceive(struct device *dev, uint8_t *tx_buf,
uint8_t tx_buf_len, uint8_t *rx_buf,
uint8_t rx_buf_len)
{
struct bmi160_device_config *dev_cfg = dev->config->config_info;
struct bmi160_device_data *bmi160 = dev->driver_data;
struct spi_config spi_cfg;
spi_cfg.config = SPI_WORD(8);
spi_cfg.max_sys_freq = dev_cfg->spi_freq;
if (spi_configure(bmi160->spi, &spi_cfg) < 0) {
SYS_LOG_DBG("Cannot configure SPI bus.");
return -EIO;
}
if (spi_slave_select(bmi160->spi, dev_cfg->spi_slave) < 0) {
SYS_LOG_DBG("Cannot select slave.");
return -EIO;
}
return spi_transceive(bmi160->spi, tx_buf, tx_buf_len,
rx_buf, rx_buf_len);
}
//! Initialise SPI for SWD
//!
//! @return BDM_RC_OK => success
//!
uint8_t initDSPI_SWD(void) {
spi_configure(SPI_CTAR_LSBFE_MASK|SPI_CTAR_FMSZ(8-1), // 8-bit transfer
SPI_CTAR_LSBFE_MASK|SPI_CTAR_FMSZ(16-1)); // 16-bit transfer
return spi_setSpeed(0);
}
void main ()
{
const unsigned int pwr_mask = (1U << pwr_pinmux.pin);
const unsigned int csn_mask = (1U << csn_pinmux.pin);
const sBSPACMdeviceEFM32periphUSARTdevcfg * spicfgp = (const sBSPACMdeviceEFM32periphUSARTdevcfg *)spi->devcfg.ptr;
const sBSPACMdeviceEFM32pinmux * const gdo1_pinmuxp = &spicfgp->uart.common.rx_pinmux;
GPIO_P_TypeDef * const pwr_port = pwr_pinmux.port;
GPIO_P_TypeDef * const csn_port = csn_pinmux.port;
GPIO_P_TypeDef * const gdo1_port = gdo1_pinmuxp->port;
const unsigned int gdo1_mask = (1U << gdo1_pinmuxp->pin);
USART_TypeDef * usart = (USART_TypeDef *)spi->uart;
const sBSPACMperiphUARTconfiguration cfg = { .speed_baud = 0 };
int rv;
uint8_t rc = 0;
(void)rv;
vBSPACMledConfigure();
SystemCoreClockUpdate();
BSPACM_CORE_ENABLE_INTERRUPT();
BSPACM_CORE_ENABLE_CYCCNT();
printf("\n" __DATE__ " " __TIME__ "\n");
printf("System clock %lu Hz\n", SystemCoreClock);
spi = spi_configure(spi, &cfg);
csn_port->DOUTSET = csn_mask;
printf("SPI at %p usart at %p\n", spi, usart);
printf("CTRL %lx\n", usart->CTRL);
vBSPACMdeviceEFM32pinmuxConfigure(&pwr_pinmux, 1, 0);
vBSPACMdeviceEFM32pinmuxConfigure(&csn_pinmux, 1, 1);
printf("GDO1 %d\n", !!(gdo1_port->DIN & gdo1_mask));
pwr_port->DOUTSET = pwr_mask;
csn_port->DOUTCLR = csn_mask;
while (! (gdo1_mask & gdo1_port->DIN)) {
}
do {
rc = sendStrobe(0x30);
printf("Reset got %x\n", rc);
} while (0x0f != rc);
printf("PARTNUM response %#02x\n", readRegister(0x30));
printf("VERSION response %#02x\n", readRegister(0x31));
printf("IOCFG2 read %#02x\n", readRegister(0x00));
printf("IOCFG1 read %#02x\n", readRegister(0x01));
printf("IOCFG0 read %#02x\n", readRegister(0x02));
/* ChipCon radios consume 1.4mA when idle. That goes down to
* nominally 400 nA if the GDOs are configured to "HW to 0" and the
* chip is told to power-down on loss of CSn. On the EXP430F5438
* the RF PWR header indicates that a CC1101 is using 40 nA in this
* mode.*/
rc = writeRegister(0x00, 0x2f);
rc = writeRegister(0x01, 0x2f);
rc = writeRegister(0x02, 0x2f);
printf("Cleared IOCFG\n");
printf("IOCFG2 read %#02x\n", readRegister(0x00));
printf("IOCFG1 read %#02x\n", readRegister(0x01));
printf("IOCFG0 read %#02x\n", readRegister(0x02));
/* SPWD */
rc = sendStrobe(0x39);
csn_port->DOUTSET = csn_mask;
printf("SPWD got %d\n", rc);
fflush(stdout);
ioctl(1, BSPACM_IOCTL_FLUSH, O_WRONLY);
}
