void spi_init(spi_t *obj_in, PinName mosi, PinName miso, PinName sclk, PinName ssel)
{
spi_obj_t *obj = OBJ_P(obj_in);
uint32_t spi = (uint32_t)NC;
en_clk_dst_t clock;
if (mosi != NC) {
spi = pinmap_merge(spi, pinmap_peripheral(mosi, PinMap_SPI_MOSI));
clock = CY_PIN_CLOCK(pinmap_function(mosi, PinMap_SPI_MOSI));
}
if (miso != NC) {
spi = pinmap_merge(spi, pinmap_peripheral(miso, PinMap_SPI_MISO));
clock = CY_PIN_CLOCK(pinmap_function(miso, PinMap_SPI_MISO));
}
if (sclk != NC) {
spi = pinmap_merge(spi, pinmap_peripheral(sclk, PinMap_SPI_SCLK));
clock = CY_PIN_CLOCK(pinmap_function(sclk, PinMap_SPI_SCLK));
}
if (ssel != NC) {
spi = pinmap_merge(spi, pinmap_peripheral(ssel, PinMap_SPI_SSEL));
clock = CY_PIN_CLOCK(pinmap_function(ssel, PinMap_SPI_SSEL));
}
if (spi != (uint32_t)NC) {
obj->base = (CySCB_Type*)spi;
obj->spi_id = ((SPIName)spi - SPI_0) / (SPI_1 - SPI_0);
obj->pin_mosi = mosi;
obj->pin_miso = miso;
obj->pin_sclk = sclk;
obj->pin_ssel = ssel;
obj->data_bits = 8;
obj->clock = clock;
obj->div_num = CY_INVALID_DIVIDER;
obj->ms_mode = CY_SCB_SPI_MASTER;
#if DEVICE_SPI_ASYNCH
obj->pending = PENDING_NONE;
obj->events = 0;
obj->tx_buffer = NULL;
obj->tx_buffer_size = 0;
obj->rx_buffer = NULL;
obj->rx_buffer_size = 0;
#endif // DEVICE_SPI_ASYNCH
spi_init_clock(obj, SPI_DEFAULT_SPEED);
spi_init_pins(obj);
spi_init_peripheral(obj);
#if DEVICE_SLEEP && DEVICE_LOWPOWERTIMER
obj->pm_callback_handler.callback = spi_pm_callback;
obj->pm_callback_handler.type = CY_SYSPM_DEEPSLEEP;
obj->pm_callback_handler.skipMode = 0;
obj->pm_callback_handler.callbackParams = &obj->pm_callback_params;
obj->pm_callback_params.base = obj->base;
obj->pm_callback_params.context = obj;
if (!Cy_SysPm_RegisterCallback(&obj->pm_callback_handler)) {
error("PM callback registration failed!");
}
#endif // DEVICE_SLEEP && DEVICE_LOWPOWERTIMER
} else {
error("SPI pinout mismatch. Requested Rx and Tx pins can't be used for the same SPI communication.");
}
}
void i2c_init(i2c_t *obj_in, PinName sda, PinName scl)
{
i2c_obj_t *obj = OBJ_P(obj_in);
uint32_t i2c = pinmap_peripheral(sda, PinMap_I2C_SDA);
i2c = pinmap_merge(i2c, pinmap_peripheral(scl, PinMap_I2C_SCL));
if (i2c != (uint32_t) NC) {
/* Initialize configuration */
obj->base = (CySCB_Type *) i2c;
obj->i2c_id = ((I2CName) i2c - I2C_0) / (I2C_1 - I2C_0);
obj->clock = CY_PIN_CLOCK(pinmap_function(scl, PinMap_I2C_SCL));
obj->divider = I2C_INVALID_DIVIDER;
obj->already_reserved = (0 != cy_reserve_scb(obj->i2c_id));
obj->pin_sda = sda;
obj->pin_scl = scl;
obj->mode = CY_SCB_I2C_MASTER;
obj->timeout = I2C_DEFAULT_TIMEOUT;
#if DEVICE_I2C_ASYNCH
obj->irqn = unconnected_IRQn;
obj->pending = PENDING_NONE;
obj->events = 0;
#endif /* DEVICE_I2C_ASYNCH */
/* Check if resource severed */
if (obj->already_reserved) {
/* SCB pins and clocks are connected */
/* Disable block and get it into the default state */
Cy_SCB_I2C_Disable(obj->base, &obj->context);
Cy_SCB_I2C_DeInit(obj->base);
/* The proper clock will be connected by i2c_init_clock(obj, I2C_DEFAULT_SPEED) */
obj->divider = I2C_DIVIDER_LOW;
} else {
#if DEVICE_SLEEP && DEVICE_LPTICKER
/* Register callback once */
obj->pm_callback_handler.callback = i2c_pm_callback;
obj->pm_callback_handler.type = CY_SYSPM_DEEPSLEEP;
obj->pm_callback_handler.skipMode = 0;
obj->pm_callback_handler.callbackParams = &obj->pm_callback_params;
obj->pm_callback_params.base = obj->base;
obj->pm_callback_params.context = obj;
if (!Cy_SysPm_RegisterCallback(&obj->pm_callback_handler)) {
error("PM callback registration failed!");
}
#endif /* DEVICE_SLEEP && DEVICE_LPTICKER */
}
/* Configure hardware resources */
i2c_init_clock(obj, I2C_DEFAULT_SPEED);
i2c_init_pins(obj);
i2c_init_peripheral(obj);
} else {
error("I2C pinout mismatch. Requested pins SDA and SCL can't be used for the same I2C communication.");
}
}
void pwmout_init(pwmout_t *obj, PinName pin)
{
uint32_t pwm_cnt = 0;
uint32_t pwm_function = 0;
uint32_t abs_cnt_num = 0;
MBED_ASSERT(obj);
MBED_ASSERT(pin != (PinName)NC);
// Allocate and setup clock.
if (pwm_clock_divider == CY_INVALID_DIVIDER) {
pwm_clock_divider = cy_clk_allocate_divider(CY_SYSCLK_DIV_8_BIT);
if (pwm_clock_divider == CY_INVALID_DIVIDER) {
error("PWM clock divider allocation failed.");
return;
}
Cy_SysClk_PeriphSetDivider(CY_SYSCLK_DIV_8_BIT,
pwm_clock_divider,
(CY_CLK_PERICLK_FREQ_HZ / PWMOUT_BASE_CLOCK_HZ) - 1);
Cy_SysClk_PeriphEnableDivider(CY_SYSCLK_DIV_8_BIT, pwm_clock_divider);
}
pwm_cnt = pinmap_peripheral(pin, PinMap_PWM_OUT);
if (pwm_cnt != (uint32_t)NC) {
if (cy_reserve_io_pin(pin)) {
error("PWMOUT pin reservation conflict.");
}
obj->base = (TCPWM_Type*)CY_PERIPHERAL_BASE(pwm_cnt);
obj->pin = pin;
if (obj->base == TCPWM0) {
obj->counter_id = ((PWMName)pwm_cnt - PWM_32b_0) / (PWM_32b_1 - PWM_32b_0);
abs_cnt_num = obj->counter_id;
} else {
// TCPWM1 is used.
obj->counter_id = ((PWMName)pwm_cnt - PWM_16b_0) / (PWM_16b_1 - PWM_16b_0);
abs_cnt_num = obj->counter_id + 8;
}
if (cy_reserve_tcpwm(abs_cnt_num)) {
error("PWMOUT Timer/Counter reservation conflict.");
}
// Configure clock.
pwm_function = pinmap_function(pin, PinMap_PWM_OUT);
obj->clock = CY_PIN_CLOCK(pwm_function);
Cy_SysClk_PeriphAssignDivider(obj->clock, CY_SYSCLK_DIV_8_BIT, pwm_clock_divider);
Cy_TCPWM_PWM_Init(obj->base, obj->counter_id, &pwm_config);
pin_function(pin, pwm_function);
// These will be properly configured later on.
obj->period = 0;
obj->pulse_width = 0;
obj->prescaler = 0;
#if DEVICE_SLEEP && DEVICE_LPTICKER
obj->pm_callback_handler.callback = pwm_pm_callback;
obj->pm_callback_handler.type = CY_SYSPM_DEEPSLEEP;
obj->pm_callback_handler.skipMode = 0;
obj->pm_callback_handler.callbackParams = &obj->pm_callback_params;
obj->pm_callback_params.base = obj->base;
obj->pm_callback_params.context = obj;
if (!Cy_SysPm_RegisterCallback(&obj->pm_callback_handler)) {
error("PM callback registration failed!");
}
#endif // DEVICE_SLEEP && DEVICE_LPTICKER
} else {
error("PWM OUT pinout mismatch.");
}
}
