/*---------------------------------------------------------------------------*/ void board_init() { /* Disable global interrupts */ uint8_t int_disabled = ti_lib_int_master_disable(); power_domains_on(); /* Configure all clock domains to run at full speed */ ti_lib_prcm_clock_configure_set(PRCM_DOMAIN_SYSBUS, PRCM_CLOCK_DIV_1); ti_lib_prcm_clock_configure_set(PRCM_DOMAIN_CPU, PRCM_CLOCK_DIV_1); ti_lib_prcm_clock_configure_set(PRCM_DOMAIN_TIMER, PRCM_CLOCK_DIV_1); ti_lib_prcm_clock_configure_set(PRCM_DOMAIN_SERIAL, PRCM_CLOCK_DIV_1); ti_lib_prcm_clock_configure_set(PRCM_DOMAIN_PERIPH, PRCM_CLOCK_DIV_1); /* Enable GPIO peripheral */ ti_lib_prcm_peripheral_run_enable(PRCM_PERIPH_GPIO); /* Apply settings and wait for them to take effect */ ti_lib_prcm_load_set(); while(!ti_lib_prcm_load_get()); /* Enable GPT0 module - Wait for the clock to be enabled */ ti_lib_prcm_peripheral_run_enable(PRCM_PERIPH_TIMER0); ti_lib_prcm_load_set(); while(!ti_lib_prcm_load_get()); /* Keys (input pullup) */ ti_lib_rom_ioc_pin_type_gpio_input(BOARD_IOID_KEY_LEFT); ti_lib_rom_ioc_pin_type_gpio_input(BOARD_IOID_KEY_RIGHT); ti_lib_ioc_io_port_pull_set(BOARD_IOID_KEY_LEFT, IOC_IOPULL_UP); ti_lib_ioc_io_port_pull_set(BOARD_IOID_KEY_RIGHT, IOC_IOPULL_UP); /* I2C controller */ board_i2c_init(); /* Sensor interface */ ti_lib_rom_ioc_pin_type_gpio_input(BOARD_IOID_MPU_INT); ti_lib_ioc_io_port_pull_set(BOARD_IOID_MPU_INT, IOC_IOPULL_DOWN); ti_lib_rom_ioc_pin_type_gpio_input(BOARD_IOID_REED_RELAY); ti_lib_ioc_io_port_pull_set(BOARD_IOID_REED_RELAY, IOC_IOPULL_DOWN); ti_lib_rom_ioc_pin_type_gpio_output(BOARD_IOID_MPU_POWER); /* Flash interface */ ti_lib_rom_ioc_pin_type_gpio_output(BOARD_IOID_FLASH_CS); ti_lib_gpio_pin_write(BOARD_FLASH_CS, 1); buzzer_init(); lpm_register_module(&sensortag_module); /* Re-enable interrupt if initially enabled. */ if(!int_disabled) { ti_lib_int_master_enable(); } }
/*---------------------------------------------------------------------------*/ void rf_core_power_down() { bool interrupts_disabled = ti_lib_int_master_disable(); ti_lib_int_disable(INT_RF_CPE0); ti_lib_int_disable(INT_RF_CPE1); if(rf_core_is_accessible()) { HWREG(RFC_DBELL_NONBUF_BASE + RFC_DBELL_O_RFCPEIFG) = 0x0; HWREG(RFC_DBELL_NONBUF_BASE + RFC_DBELL_O_RFCPEIEN) = 0x0; /* need to send FS_POWERDOWN or analog components will use power */ fs_powerdown(); } /* Shut down the RFCORE clock domain in the MCU VD */ ti_lib_prcm_domain_disable(PRCM_DOMAIN_RFCORE); ti_lib_prcm_load_set(); while(!ti_lib_prcm_load_get()); /* Turn off RFCORE PD */ ti_lib_prcm_power_domain_off(PRCM_DOMAIN_RFCORE); while(ti_lib_prcm_power_domain_status(PRCM_DOMAIN_RFCORE) != PRCM_DOMAIN_POWER_OFF); ti_lib_int_pend_clear(INT_RF_CPE0); ti_lib_int_pend_clear(INT_RF_CPE1); ti_lib_int_enable(INT_RF_CPE0); ti_lib_int_enable(INT_RF_CPE1); if(!interrupts_disabled) { ti_lib_int_master_enable(); } }
/*---------------------------------------------------------------------------*/ void cc26xx_uart_set_input(int (*input)(unsigned char c)) { input_handler = input; /* Return early if disabled by user conf or if ports are misconfigured */ if(usable() == false) { return; } if(input == NULL) { /* Let the SERIAL PD power down */ uart_module.domain_lock = LPM_DOMAIN_NONE; /* Disable module clocks under sleep and deep sleep */ ti_lib_prcm_peripheral_sleep_disable(PRCM_PERIPH_UART0); ti_lib_prcm_peripheral_deep_sleep_disable(PRCM_PERIPH_UART0); } else { /* Request the SERIAL PD to stay on during deep sleep */ uart_module.domain_lock = LPM_DOMAIN_SERIAL; /* Enable module clocks under sleep and deep sleep */ ti_lib_prcm_peripheral_sleep_enable(PRCM_PERIPH_UART0); ti_lib_prcm_peripheral_deep_sleep_enable(PRCM_PERIPH_UART0); } ti_lib_prcm_load_set(); while(!ti_lib_prcm_load_get()); enable(); return; }
/*---------------------------------------------------------------------------*/ void board_i2c_shutdown() { interface = NO_INTERFACE; if(accessible()) { ti_lib_i2c_master_disable(I2C0_BASE); } ti_lib_prcm_peripheral_run_disable(PRCM_PERIPH_I2C0); ti_lib_prcm_load_set(); while(!ti_lib_prcm_load_get()); /* * Set all pins to GPIO Input and disable the output driver. Set internal * pull to match external pull * * SDA and SCL: external PU resistor * SDA HP and SCL HP: MPU PWR low */ ti_lib_ioc_pin_type_gpio_input(BOARD_IOID_SDA_HP); ti_lib_ioc_io_port_pull_set(BOARD_IOID_SDA_HP, IOC_IOPULL_DOWN); ti_lib_ioc_pin_type_gpio_input(BOARD_IOID_SCL_HP); ti_lib_ioc_io_port_pull_set(BOARD_IOID_SCL_HP, IOC_IOPULL_DOWN); ti_lib_ioc_pin_type_gpio_input(BOARD_IOID_SDA); ti_lib_ioc_io_port_pull_set(BOARD_IOID_SDA, IOC_IOPULL_UP); ti_lib_ioc_pin_type_gpio_input(BOARD_IOID_SCL); ti_lib_ioc_io_port_pull_set(BOARD_IOID_SCL, IOC_IOPULL_UP); }
/*---------------------------------------------------------------------------*/ void board_init() { uint8_t int_disabled = ti_lib_int_master_disable(); /* Turn on relevant PDs */ wakeup_handler(); /* Enable GPIO peripheral */ ti_lib_prcm_peripheral_run_enable(PRCM_PERIPH_GPIO); /* Apply settings and wait for them to take effect */ ti_lib_prcm_load_set(); while (!ti_lib_prcm_load_get()) ; lpm_register_module(&srf_module); /* Re-enable interrupt if initially enabled. */ if (!int_disabled) { ti_lib_int_master_enable(); } /* Init of PWM */ pwm_init(); }
/*---------------------------------------------------------------------------*/ void buzzer_start(int freq) { uint32_t load; buzzer_on = 1; lpm_pd_lock_obtain(&lock, PRCM_DOMAIN_PERIPH); /* Stop the timer */ ti_lib_timer_disable(GPT0_BASE, TIMER_A); if(freq > 0) { load = (GET_MCU_CLOCK / freq); ti_lib_timer_load_set(GPT0_BASE, TIMER_A, load); ti_lib_timer_match_set(GPT0_BASE, TIMER_A, load / 2); /* Start */ ti_lib_timer_enable(GPT0_BASE, TIMER_A); } /* Run in sleep mode */ ti_lib_prcm_peripheral_sleep_enable(PRCM_PERIPH_TIMER0); ti_lib_prcm_peripheral_deep_sleep_enable(PRCM_PERIPH_TIMER0); ti_lib_prcm_load_set(); while(!ti_lib_prcm_load_get()); }
/*---------------------------------------------------------------------------*/ void board_init() { /* Disable global interrupts */ bool int_disabled = ti_lib_int_master_disable(); /* Turn on relevant PDs */ wakeup_handler(); /* Enable GPIO peripheral */ ti_lib_prcm_peripheral_run_enable(PRCM_PERIPH_GPIO); /* Apply settings and wait for them to take effect */ ti_lib_prcm_load_set(); while(!ti_lib_prcm_load_get()); /* Make sure the external flash is in the lower power mode */ ext_flash_init(); lpm_register_module(&launchpad_module); /* For unsupported peripherals, select a default pin configuration */ configure_unused_pins(); /* Re-enable interrupt if initially enabled. */ if(!int_disabled) { ti_lib_int_master_enable(); } }
/*---------------------------------------------------------------------------*/ void board_spi_close() { /* Power down SSI0 */ ti_lib_rom_prcm_peripheral_run_disable(PRCM_PERIPH_SSI0); ti_lib_prcm_load_set(); while(!ti_lib_prcm_load_get()); }
/*---------------------------------------------------------------------------*/ static void lpm_drop_handler(uint8_t mode) { /* * First, wait for any outstanding TX to complete. If we have an input * handler, the SERIAL PD will be kept on and the UART module clock will * be enabled under sleep as well as deep sleep. In theory, this means that * we shouldn't lose any outgoing bytes, but we actually do on occasion. * This byte loss may (or may not) be related to the freezing of IO latches * between MCU and AON when we drop to deep sleep. This here is essentially a * workaround */ if(accessible() == true) { while(ti_lib_uart_busy(UART0_BASE)); } /* * If we have a registered input_handler then we need to retain RX * capability. Thus, if this is not a shutdown notification and we have an * input handler, we do nothing */ if((mode != LPM_MODE_SHUTDOWN) && (input_handler != NULL)) { return; } /* * If we reach here, we either don't care about staying awake or we have * received a shutdown notification * * Only touch UART registers if the module is powered and clocked */ if(accessible() == true) { /* Disable the module */ ti_lib_uart_disable(UART0_BASE); /* Disable all UART interrupts and clear all flags */ disable_interrupts(); } /* * Always stop the clock in run mode. Also stop in Sleep and Deep Sleep if * this is a request for full shutdown */ ti_lib_prcm_peripheral_run_disable(PRCM_PERIPH_UART0); if(mode == LPM_MODE_SHUTDOWN) { ti_lib_prcm_peripheral_sleep_disable(PRCM_PERIPH_UART0); ti_lib_prcm_peripheral_deep_sleep_disable(PRCM_PERIPH_UART0); } ti_lib_prcm_load_set(); while(!ti_lib_prcm_load_get()); /* Set pins to low leakage configuration in preparation for deep sleep */ lpm_pin_set_default_state(BOARD_IOID_UART_TX); lpm_pin_set_default_state(BOARD_IOID_UART_RX); lpm_pin_set_default_state(BOARD_IOID_UART_CTS); lpm_pin_set_default_state(BOARD_IOID_UART_RTS); }
/*---------------------------------------------------------------------------*/ static void power_and_clock(void) { /* Power on the SERIAL PD */ ti_lib_prcm_power_domain_on(PRCM_DOMAIN_SERIAL); while(ti_lib_prcm_power_domain_status(PRCM_DOMAIN_SERIAL) != PRCM_DOMAIN_POWER_ON); /* Enable UART clock in active mode */ ti_lib_prcm_peripheral_run_enable(PRCM_PERIPH_UART0); ti_lib_prcm_load_set(); while(!ti_lib_prcm_load_get()); }
/*---------------------------------------------------------------------------*/ void board_i2c_wakeup() { /* First, make sure the SERIAL PD is on */ ti_lib_prcm_power_domain_on(PRCM_DOMAIN_SERIAL); while((ti_lib_prcm_power_domain_status(PRCM_DOMAIN_SERIAL) != PRCM_DOMAIN_POWER_ON)); /* Enable the clock to I2C */ ti_lib_prcm_peripheral_run_enable(PRCM_PERIPH_I2C0); ti_lib_prcm_load_set(); while(!ti_lib_prcm_load_get()); /* Enable and initialize the I2C master module */ ti_lib_i2c_master_init_exp_clk(I2C0_BASE, ti_lib_sys_ctrl_clock_get(), true); }
/*---------------------------------------------------------------------------*/ int rf_core_power_up() { uint32_t cmd_status; bool interrupts_disabled = ti_lib_int_master_disable(); ti_lib_int_pend_clear(INT_RF_CPE0); ti_lib_int_pend_clear(INT_RF_CPE1); ti_lib_int_disable(INT_RF_CPE0); ti_lib_int_disable(INT_RF_CPE1); /* Enable RF Core power domain */ ti_lib_prcm_power_domain_on(PRCM_DOMAIN_RFCORE); while(ti_lib_prcm_power_domain_status(PRCM_DOMAIN_RFCORE) != PRCM_DOMAIN_POWER_ON); ti_lib_prcm_domain_enable(PRCM_DOMAIN_RFCORE); ti_lib_prcm_load_set(); while(!ti_lib_prcm_load_get()); while(!rf_core_is_accessible()) { PRINTF("rf_core_power_up: Not ready\n"); } HWREG(RFC_DBELL_NONBUF_BASE + RFC_DBELL_O_RFCPEIFG) = 0x0; HWREG(RFC_DBELL_NONBUF_BASE + RFC_DBELL_O_RFCPEIEN) = 0x0; ti_lib_int_enable(INT_RF_CPE0); ti_lib_int_enable(INT_RF_CPE1); if(!interrupts_disabled) { ti_lib_int_master_enable(); } /* Let CPE boot */ HWREG(RFC_PWR_NONBUF_BASE + RFC_PWR_O_PWMCLKEN) = RF_CORE_CLOCKS_MASK; /* Send ping (to verify RFCore is ready and alive) */ if(rf_core_send_cmd(CMDR_DIR_CMD(CMD_PING), &cmd_status) != RF_CORE_CMD_OK) { PRINTF("rf_core_power_up: CMD_PING fail, CMDSTA=0x%08lx\n", cmd_status); return RF_CORE_CMD_ERROR; } return RF_CORE_CMD_OK; }
/*---------------------------------------------------------------------------*/ void board_spi_open(uint32_t bit_rate, uint32_t clk_pin) { uint32_t buf; /* SPI power */ ti_lib_rom_prcm_peripheral_run_enable(PRCM_PERIPH_SSI0); ti_lib_prcm_load_set(); while(!ti_lib_prcm_load_get()); /* SPI configuration */ ti_lib_ssi_int_disable(SSI0_BASE, SSI_RXOR | SSI_RXFF | SSI_RXTO | SSI_TXFF); ti_lib_ssi_int_clear(SSI0_BASE, SSI_RXOR | SSI_RXTO); ti_lib_rom_ssi_config_set_exp_clk(SSI0_BASE, CPU_FREQ, SSI_FRF_MOTO_MODE_0, SSI_MODE_MASTER, bit_rate, 8); ti_lib_rom_ioc_pin_type_ssi_master(SSI0_BASE, BOARD_IOID_SPI_MISO, BOARD_IOID_SPI_MOSI, IOID_UNUSED, clk_pin); ti_lib_ssi_enable(SSI0_BASE); /* Get rid of residual data from SSI port */ while(ti_lib_ssi_data_get_non_blocking(SSI0_BASE, &buf)); }
/*---------------------------------------------------------------------------*/ void buzzer_stop() { buzzer_on = 0; lpm_pd_lock_release(&lock); /* Stop the timer */ ti_lib_timer_disable(GPT0_BASE, TIMER_A); /* * Stop running in sleep mode. * ToDo: Currently GPT0 is in use by clock_delay_usec (GPT0/TB) and by this * module here (GPT0/TA). clock_delay_usec will never need GPT0/TB in sleep * mode and we control TA here. Thus, with the current setup, it's OK to * control whether GPT0 runs in sleep mode in this module here. However, if * some other module at some point starts using GPT0, we should change this * to happen through an umbrella module */ ti_lib_prcm_peripheral_sleep_disable(PRCM_PERIPH_TIMER0); ti_lib_prcm_peripheral_deep_sleep_disable(PRCM_PERIPH_TIMER0); ti_lib_prcm_load_set(); while(!ti_lib_prcm_load_get()); }