void serial_baud(serial_t *obj, int baudrate)
{
/* Sanity check arguments */
MBED_ASSERT(obj);
MBED_ASSERT((baudrate == 110) || (baudrate == 150) || (baudrate == 300) || (baudrate == 1200) ||
(baudrate == 2400) || (baudrate == 4800) || (baudrate == 9600) || (baudrate == 19200) || (baudrate == 38400) ||
(baudrate == 57600) || (baudrate == 115200) || (baudrate == 230400) || (baudrate == 460800) || (baudrate == 921600) );
struct system_gclk_chan_config gclk_chan_conf;
uint32_t gclk_index;
uint16_t baud = 0;
uint32_t sercom_index = 0;
enum sercom_asynchronous_operation_mode mode = SERCOM_ASYNC_OPERATION_MODE_ARITHMETIC;
enum sercom_asynchronous_sample_num sample_num = SERCOM_ASYNC_SAMPLE_NUM_16;
pSERIAL_S(obj)->baudrate = baudrate;
disable_usart(obj);
sercom_index = _sercom_get_sercom_inst_index(pUSART_S(obj));
#if (SAML21) || (SAMC20) || (SAMC21)
#if (SAML21)
if (sercom_index == 5) {
gclk_index = SERCOM5_GCLK_ID_CORE;
} else {
gclk_index = sercom_index + SERCOM0_GCLK_ID_CORE;
}
#else
gclk_index = sercom_index + SERCOM0_GCLK_ID_CORE;
#endif
#else
gclk_index = sercom_index + SERCOM0_GCLK_ID_CORE;
#endif
gclk_chan_conf.source_generator = GCLK_GENERATOR_0;
system_gclk_chan_set_config(gclk_index, &gclk_chan_conf);
system_gclk_chan_enable(gclk_index);
sercom_set_gclk_generator(GCLK_GENERATOR_0, false);
/* Get baud value from mode and clock */
_sercom_get_async_baud_val(pSERIAL_S(obj)->baudrate, system_gclk_chan_get_hz(gclk_index), &baud, mode, sample_num);
/* Wait until synchronization is complete */
usart_syncing(obj);
/*Set baud val */
_USART(obj).BAUD.reg = baud;
/* Wait until synchronization is complete */
usart_syncing(obj);
enable_usart(obj);
}
/**
* \brief Initializes the requested I<SUP>2</SUP>C hardware module
*
* Initializes the SERCOM I<SUP>2</SUP>C slave device requested and sets the provided
* software module struct. Run this function before any further use of
* the driver.
*
* \param[out] module Pointer to software module struct
* \param[in] hw Pointer to the hardware instance
* \param[in] config Pointer to the configuration struct
*
* \return Status of initialization.
* \retval STATUS_OK Module initiated correctly
* \retval STATUS_ERR_DENIED If module is enabled
* \retval STATUS_BUSY If module is busy resetting
* \retval STATUS_ERR_ALREADY_INITIALIZED If setting other GCLK generator than
* previously set
*/
enum status_code i2c_slave_init(
struct i2c_slave_module *const module,
Sercom *const hw,
const struct i2c_slave_config *const config)
{
/* Sanity check arguments */
Assert(module);
Assert(hw);
Assert(config);
/* Initialize software module */
module->hw = hw;
SercomI2cs *const i2c_hw = &(module->hw->I2CS);
/* Check if module is enabled */
if (i2c_hw->CTRLA.reg & SERCOM_I2CS_CTRLA_ENABLE) {
return STATUS_ERR_DENIED;
}
/* Check if reset is in progress */
if (i2c_hw->CTRLA.reg & SERCOM_I2CS_CTRLA_SWRST) {
return STATUS_BUSY;
}
uint32_t sercom_index = _sercom_get_sercom_inst_index(module->hw);
uint32_t pm_index, gclk_index;
#if (SAML21) || (SAML22) || (SAMC20) || (SAMC21)
#if (SAML21)
if (sercom_index == 5) {
pm_index = MCLK_APBDMASK_SERCOM5_Pos;
gclk_index = SERCOM5_GCLK_ID_CORE;
} else {
pm_index = sercom_index + MCLK_APBCMASK_SERCOM0_Pos;
gclk_index = sercom_index + SERCOM0_GCLK_ID_CORE;
}
#else
pm_index = sercom_index + MCLK_APBCMASK_SERCOM0_Pos;
gclk_index = sercom_index + SERCOM0_GCLK_ID_CORE;
#endif
#else
pm_index = sercom_index + PM_APBCMASK_SERCOM0_Pos;
gclk_index = sercom_index + SERCOM0_GCLK_ID_CORE;
#endif
/* Turn on module in PM */
#if (SAML21)
if (sercom_index == 5) {
system_apb_clock_set_mask(SYSTEM_CLOCK_APB_APBD, 1 << pm_index);
} else {
system_apb_clock_set_mask(SYSTEM_CLOCK_APB_APBC, 1 << pm_index);
}
#else
system_apb_clock_set_mask(SYSTEM_CLOCK_APB_APBC, 1 << pm_index);
#endif
/* Set up the GCLK for the module */
struct system_gclk_chan_config gclk_chan_conf;
system_gclk_chan_get_config_defaults(&gclk_chan_conf);
gclk_chan_conf.source_generator = config->generator_source;
system_gclk_chan_set_config(gclk_index, &gclk_chan_conf);
system_gclk_chan_enable(gclk_index);
sercom_set_gclk_generator(config->generator_source, false);
#if I2C_SLAVE_CALLBACK_MODE == true
/* Get sercom instance index */
uint8_t instance_index = _sercom_get_sercom_inst_index(module->hw);
/* Save software module in interrupt handler */
_sercom_set_handler(instance_index, _i2c_slave_interrupt_handler);
/* Save software module */
_sercom_instances[instance_index] = module;
/* Initialize values in module */
module->registered_callback = 0;
module->enabled_callback = 0;
module->buffer_length = 0;
module->nack_on_address = config->enable_nack_on_address;
#endif
/* Set SERCOM module to operate in I2C slave mode */
i2c_hw->CTRLA.reg = SERCOM_I2CS_CTRLA_MODE(0x4);
/* Set config and return status */
return _i2c_slave_set_config(module, config);
}
/**
* \brief Initializes the device
*
* Initializes the USART device based on the setting specified in the
* configuration struct.
*
* \param[out] module Pointer to USART device
* \param[in] hw Pointer to USART hardware instance
* \param[in] config Pointer to configuration struct
*
* \return Status of the initialization.
*
* \retval STATUS_OK The initialization was successful
* \retval STATUS_BUSY The USART module is busy
* resetting
* \retval STATUS_ERR_DENIED The USART have not been disabled in
* advance of initialization
* \retval STATUS_ERR_INVALID_ARG The configuration struct contains
* invalid configuration
* \retval STATUS_ERR_ALREADY_INITIALIZED The SERCOM instance has already been
* initialized with different clock
* configuration
* \retval STATUS_ERR_BAUD_UNAVAILABLE The BAUD rate given by the
* configuration
* struct cannot be reached with
* the current clock configuration
*/
enum status_code usart_init(
struct usart_module *const module,
Sercom *const hw,
const struct usart_config *const config)
{
/* Sanity check arguments */
Assert(module);
Assert(hw);
Assert(config);
enum status_code status_code = STATUS_OK;
/* Assign module pointer to software instance struct */
module->hw = hw;
/* Get a pointer to the hardware module instance */
SercomUsart *const usart_hw = &(module->hw->USART);
uint32_t sercom_index = _sercom_get_sercom_inst_index(module->hw);
#if (SAML21)
uint32_t pm_index = sercom_index + MCLK_APBCMASK_SERCOM0_Pos;
#else
uint32_t pm_index = sercom_index + PM_APBCMASK_SERCOM0_Pos;
#endif
uint32_t gclk_index = sercom_index + SERCOM0_GCLK_ID_CORE;
if (usart_hw->CTRLA.reg & SERCOM_USART_CTRLA_SWRST) {
/* The module is busy resetting itself */
return STATUS_BUSY;
}
if (usart_hw->CTRLA.reg & SERCOM_USART_CTRLA_ENABLE) {
/* Check the module is enabled */
return STATUS_ERR_DENIED;
}
/* Turn on module in PM */
system_apb_clock_set_mask(SYSTEM_CLOCK_APB_APBC, 1 << pm_index);
/* Set up the GCLK for the module */
struct system_gclk_chan_config gclk_chan_conf;
system_gclk_chan_get_config_defaults(&gclk_chan_conf);
gclk_chan_conf.source_generator = config->generator_source;
system_gclk_chan_set_config(gclk_index, &gclk_chan_conf);
system_gclk_chan_enable(gclk_index);
sercom_set_gclk_generator(config->generator_source, false);
/* Set character size */
module->character_size = config->character_size;
/* Set transmitter and receiver status */
module->receiver_enabled = config->receiver_enable;
module->transmitter_enabled = config->transmitter_enable;
#ifdef FEATURE_USART_LIN_SLAVE
module->lin_slave_enabled = config->lin_slave_enable;
#endif
#ifdef FEATURE_USART_START_FRAME_DECTION
module->start_frame_detection_enabled = config->start_frame_detection_enable;
#endif
/* Set configuration according to the config struct */
status_code = _usart_set_config(module, config);
if(status_code != STATUS_OK) {
return status_code;
}
struct system_pinmux_config pin_conf;
system_pinmux_get_config_defaults(&pin_conf);
pin_conf.direction = SYSTEM_PINMUX_PIN_DIR_INPUT;
pin_conf.input_pull = SYSTEM_PINMUX_PIN_PULL_NONE;
uint32_t pad_pinmuxes[] = {
config->pinmux_pad0, config->pinmux_pad1,
config->pinmux_pad2, config->pinmux_pad3
};
/* Configure the SERCOM pins according to the user configuration */
for (uint8_t pad = 0; pad < 4; pad++) {
uint32_t current_pinmux = pad_pinmuxes[pad];
if (current_pinmux == PINMUX_DEFAULT) {
current_pinmux = _sercom_get_default_pad(hw, pad);
}
if (current_pinmux != PINMUX_UNUSED) {
pin_conf.mux_position = current_pinmux & 0xFFFF;
system_pinmux_pin_set_config(current_pinmux >> 16, &pin_conf);
}
}
/**
* \brief Initialize hardware and driver instance
*
* This function configures the clock system for the specified SERCOM module,
* sets up the related pins and their MUX, initializes the SERCOM in SPI master
* mode, and prepares the driver instance for operation.
*
* \pre \ref system_init() must have been called prior to this function.
*
* The SERCOM SPI module is left disabled after initialization, and must be
* enabled with \ref spi_master_vec_enable() before a transfer can be done.
*
* \param[out] module Driver instance to initialize.
* \param[in,out] sercom SERCOM module to initialize and associate driver
* instance with.
* \param[in] config Driver configuration to use.
*
* \return Status of initialization.
* \retval STATUS_OK if initialization succeeded.
* \retval STATUS_ERR_INVALID_ARG if driver has been misconfigured.
*/
enum status_code spi_master_vec_init(struct spi_master_vec_module *const module,
Sercom *const sercom, const struct spi_master_vec_config *const config)
{
Assert(module);
Assert(sercom);
Assert(config);
enum status_code status;
SercomSpi *const spi_hw = &(sercom->SPI);
struct system_gclk_chan_config gclk_chan_conf;
uint16_t tmp_baud;
uint32_t sercom_index = _sercom_get_sercom_inst_index((Sercom *)spi_hw);
#if (SAML21) || (SAML22) || (SAMC20) || (SAMC21) || (SAMR30)
uint32_t pm_index = sercom_index + MCLK_APBCMASK_SERCOM0_Pos;
#else
uint32_t pm_index = sercom_index + PM_APBCMASK_SERCOM0_Pos;
#endif
uint32_t gclk_index = sercom_index + SERCOM0_GCLK_ID_CORE;
uint32_t gclk_hz;
module->sercom = sercom;
/* Enable clock for the module interface */
system_apb_clock_set_mask(SYSTEM_CLOCK_APB_APBC, 1 << pm_index);
/* Set up the GCLK for the module */
system_gclk_chan_get_config_defaults(&gclk_chan_conf);
gclk_chan_conf.source_generator = config->gclk_generator;
system_gclk_chan_set_config(gclk_index, &gclk_chan_conf);
system_gclk_chan_enable(gclk_index);
sercom_set_gclk_generator(config->gclk_generator, false);
_spi_master_vec_wait_for_sync(spi_hw);
/* Set up the SERCOM SPI module as master */
spi_hw->CTRLA.reg = SERCOM_SPI_CTRLA_MODE(0x3);
spi_hw->CTRLA.reg |= (uint32_t)config->mux_setting
| config->transfer_mode
| config->data_order
| ((config->run_in_standby || system_is_debugger_present()) ?
SERCOM_SPI_CTRLA_RUNSTDBY : 0);
/* Get baud value from configured baudrate and internal clock rate */
gclk_hz = system_gclk_chan_get_hz(gclk_index);
status = _sercom_get_sync_baud_val(config->baudrate, gclk_hz, &tmp_baud);
if (status != STATUS_OK) {
/* Baud rate calculation error! */
return STATUS_ERR_INVALID_ARG;
}
spi_hw->BAUD.reg = (uint8_t)tmp_baud;
/* Configure the pin multiplexers */
_spi_master_vec_pinmux_helper(config->pinmux_pad0, sercom, 0);
_spi_master_vec_pinmux_helper(config->pinmux_pad3, sercom, 3);
/* SERCOM PAD1 and PAD2 are used for slave SS.
* This is a SPI master driver, so control of slave SS must be left to
* the PORT module, i.e., peripheral MUX should not be set for that pin.
* DOPO controls which PAD is used for slave SS:
* If DOPO is odd, SERCOM_PAD1 is SS: SERCOM_PAD2 can be MUXed.
* If DOPO is even, SERCOM_PAD2 is SS: SERCOM_PAD1 can be MUXed.
*/
if (config->mux_setting & (1 << SERCOM_SPI_CTRLA_DOPO_Pos)) {
_spi_master_vec_pinmux_helper(config->pinmux_pad2, sercom, 2);
} else {
_spi_master_vec_pinmux_helper(config->pinmux_pad1, sercom, 1);
}
/* Initialize our instance and register interrupt handler + data */
module->rx_bufdesc_ptr = NULL;
module->tx_bufdesc_ptr = NULL;
module->direction = SPI_MASTER_VEC_DIRECTION_IDLE;
module->status = STATUS_OK;
#ifdef CONF_SPI_MASTER_VEC_OS_SUPPORT
CONF_SPI_MASTER_VEC_CREATE_SEMAPHORE(module->busy_semaphore);
#endif
_sercom_set_handler(sercom_index, _spi_master_vec_int_handler);
_sercom_instances[sercom_index] = module;
return STATUS_OK;
}
/**
* \brief Initialize and enable debug UART
*
* This function sets up the configured SERCOM with the following static
* features:
* - asynchronous, internally clocked (UART)
* - TX only
* - 1 stop bit
* - 8-bit data
* - LSB first
* - no parity bit
*
* The baud rate, SERCOM signal MUX and pin MUX are set up as configured in
* \ref conf_debug_print.h, which also contains the configuration of which
* SERCOM to use.
*
* The SERCOM UART is left enabled after this function call.
*
* \return Indication whether or not initialization succeeded.
* \retval STATUS_OK if initialization was successful.
* \retval STATUS_ERR_BAUDRATE_UNAVAILABLE if configured baud rate is too high.
*
* \note This function is based on \ref usart_init() from ASF, but is modified
* to use a single instance in order to reduce code size.
*/
enum status_code dbg_init(void)
{
enum status_code status = STATUS_OK;
Sercom *const sercom = CONF_DBG_PRINT_SERCOM;
struct system_gclk_chan_config gclk_chan_conf;
struct system_pinmux_config pin_conf;
uint16_t baud;
uint32_t sercom_index, pm_index, gclk_index;
#if defined(__FREERTOS__) || defined(__DOXYGEN__)
dbg_is_free = xSemaphoreCreateMutex();
vSemaphoreCreateBinary(requested_space_is_free);
xSemaphoreTake(requested_space_is_free, 0);
#else
requested_space_is_free = false;
#endif
// Get required indexes
sercom_index = _sercom_get_sercom_inst_index(sercom);
pm_index = sercom_index + PM_APBCMASK_SERCOM0_Pos;
gclk_index = sercom_index + SERCOM0_GCLK_ID_CORE;
// Turn on module in PM
system_apb_clock_set_mask(SYSTEM_CLOCK_APB_APBC, 1 << pm_index);
// Set up the GCLK for the module
system_gclk_chan_get_config_defaults(&gclk_chan_conf);
gclk_chan_conf.source_generator = CONF_DBG_PRINT_GCLK_SOURCE;
system_gclk_chan_set_config(gclk_index, &gclk_chan_conf);
system_gclk_chan_enable(gclk_index);
sercom_set_gclk_generator(CONF_DBG_PRINT_GCLK_SOURCE, false);
#if defined(CONF_DBG_PRINT_BAUD_VALUE)
baud = CONF_DBG_PRINT_BAUD_VALUE;
#else
// Compute baud rate, if it is achievable
status = _sercom_get_async_baud_val(CONF_DBG_PRINT_BAUD_RATE,
system_gclk_chan_get_hz(gclk_index), &baud);
if (status != STATUS_OK) {
return status;
}
#endif
sercom_uart->BAUD.reg = baud;
sercom_uart->CTRLB.reg = SERCOM_USART_CTRLB_TXEN;
sercom_uart->CTRLA.reg = SERCOM_USART_CTRLA_MODE_USART_INT_CLK
| SERCOM_USART_CTRLA_DORD | SERCOM_USART_CTRLA_ENABLE
| CONF_DBG_PRINT_SERCOM_MUX | (system_is_debugger_present() ?
SERCOM_USART_CTRLA_RUNSTDBY : 0);
// Set up the pin MUXes
system_pinmux_get_config_defaults(&pin_conf);
pin_conf.direction = SYSTEM_PINMUX_PIN_DIR_INPUT;
uint32_t pad_pinmuxes[] = {
CONF_DBG_PRINT_PINMUX_PAD0,
CONF_DBG_PRINT_PINMUX_PAD1,
CONF_DBG_PRINT_PINMUX_PAD2,
CONF_DBG_PRINT_PINMUX_PAD3,
};
for (uint8_t pad = 0; pad < 4; pad++) {
uint32_t current_pinmux = pad_pinmuxes[pad];
if (current_pinmux == PINMUX_DEFAULT) {
current_pinmux = _sercom_get_default_pad(sercom, pad);
}
if (current_pinmux != PINMUX_UNUSED) {
pin_conf.mux_position = current_pinmux & 0xFFFF;
system_pinmux_pin_set_config(current_pinmux >> 16, &pin_conf);
}
}
/**
* \brief Initializes the requested I<SUP>2</SUP>C hardware module
*
* Initializes the SERCOM I<SUP>2</SUP>C master device requested and sets the provided
* software module struct. Run this function before any further use of
* the driver.
*
* \param[out] module Pointer to software module struct
* \param[in] hw Pointer to the hardware instance
* \param[in] config Pointer to the configuration struct
*
* \return Status of initialization.
* \retval STATUS_OK Module initiated correctly
* \retval STATUS_ERR_DENIED If module is enabled
* \retval STATUS_BUSY If module is busy resetting
* \retval STATUS_ERR_ALREADY_INITIALIZED If setting other GCLK generator than
* previously set
* \retval STATUS_ERR_BAUDRATE_UNAVAILABLE If given baudrate is not compatible
* with set GCLK frequency
*
*/
enum status_code i2c_master_init(
struct i2c_master_module *const module,
Sercom *const hw,
const struct i2c_master_config *const config)
{
/* Sanity check arguments. */
Assert(module);
Assert(hw);
Assert(config);
/* Initialize software module */
module->hw = hw;
SercomI2cm *const i2c_module = &(module->hw->I2CM);
uint32_t sercom_index = _sercom_get_sercom_inst_index(module->hw);
#if (SAML21)
uint32_t pm_index = sercom_index + MCLK_APBCMASK_SERCOM0_Pos;
#else
uint32_t pm_index = sercom_index + PM_APBCMASK_SERCOM0_Pos;
#endif
uint32_t gclk_index = sercom_index + SERCOM0_GCLK_ID_CORE;
/* Turn on module in PM */
system_apb_clock_set_mask(SYSTEM_CLOCK_APB_APBC, 1 << pm_index);
/* Set up the GCLK for the module */
struct system_gclk_chan_config gclk_chan_conf;
system_gclk_chan_get_config_defaults(&gclk_chan_conf);
gclk_chan_conf.source_generator = config->generator_source;
system_gclk_chan_set_config(gclk_index, &gclk_chan_conf);
system_gclk_chan_enable(gclk_index);
sercom_set_gclk_generator(config->generator_source, false);
/* Check if module is enabled. */
if (i2c_module->CTRLA.reg & SERCOM_I2CM_CTRLA_ENABLE) {
return STATUS_ERR_DENIED;
}
/* Check if reset is in progress. */
if (i2c_module->CTRLA.reg & SERCOM_I2CM_CTRLA_SWRST) {
return STATUS_BUSY;
}
#if I2C_MASTER_CALLBACK_MODE == true
/* Get sercom instance index and register callback. */
uint8_t instance_index = _sercom_get_sercom_inst_index(module->hw);
_sercom_set_handler(instance_index, _i2c_master_interrupt_handler);
_sercom_instances[instance_index] = module;
/* Initialize values in module. */
module->registered_callback = 0;
module->enabled_callback = 0;
module->buffer_length = 0;
module->buffer_remaining = 0;
module->status = STATUS_OK;
module->buffer = NULL;
#endif
/* Set sercom module to operate in I2C master mode. */
i2c_module->CTRLA.reg = SERCOM_I2CM_CTRLA_MODE(0x5);
/* Set config and return status. */
return _i2c_master_set_config(module, config);
}
/** Initialize the SPI peripheral
*
* Configures the pins used by SPI, sets a default format and frequency, and enables the peripheral
* @param[out] obj The SPI object to initialize
* @param[in] mosi The pin to use for MOSI
* @param[in] miso The pin to use for MISO
* @param[in] sclk The pin to use for SCLK
* @param[in] ssel The pin to use for SSEL
*/
void spi_init(spi_t *obj, PinName mosi, PinName miso, PinName sclk, PinName ssel)
{
uint16_t baud = 0;
uint32_t ctrla = 0;
uint32_t ctrlb = 0;
enum status_code error_code;
if (g_sys_init == 0) {
system_init();
g_sys_init = 1;
}
/* TODO: Calculate SERCOM instance from pins */
/* TEMP: Giving external SPI module value of SAMR21 for now */
pSPI_SERCOM(obj) = EXT1_SPI_MODULE;
/* Disable SPI */
spi_disable(obj);
/* Check if reset is in progress. */
if (_SPI(obj).CTRLA.reg & SERCOM_SPI_CTRLA_SWRST) {
return;
}
uint32_t sercom_index = _sercom_get_sercom_inst_index(pSPI_SERCOM(obj));
uint32_t pm_index, gclk_index;
#if (SAML21)
if (sercom_index == 5) {
pm_index = MCLK_APBDMASK_SERCOM5_Pos;
gclk_index = SERCOM5_GCLK_ID_CORE;
} else {
pm_index = sercom_index + MCLK_APBCMASK_SERCOM0_Pos;
gclk_index = sercom_index + SERCOM0_GCLK_ID_CORE;
}
#else
pm_index = sercom_index + PM_APBCMASK_SERCOM0_Pos;
gclk_index = sercom_index + SERCOM0_GCLK_ID_CORE;
#endif
/* Turn on module in PM */
#if (SAML21)
if (sercom_index == 5) {
system_apb_clock_set_mask(SYSTEM_CLOCK_APB_APBD, 1 << pm_index);
} else {
system_apb_clock_set_mask(SYSTEM_CLOCK_APB_APBC, 1 << pm_index);
}
#else
system_apb_clock_set_mask(SYSTEM_CLOCK_APB_APBC, 1 << pm_index);
#endif
/* Set up the GCLK for the module */
struct system_gclk_chan_config gclk_chan_conf;
system_gclk_chan_get_config_defaults(&gclk_chan_conf);
gclk_chan_conf.source_generator = GCLK_GENERATOR_0;
system_gclk_chan_set_config(gclk_index, &gclk_chan_conf);
system_gclk_chan_enable(gclk_index);
sercom_set_gclk_generator(GCLK_GENERATOR_0, false);
#if DEVICE_SPI_ASYNCH
/* Save the object */
_sercom_instances[sercom_index] = obj;
/* Configure interrupt handler */
NVIC_SetVector((SERCOM0_IRQn + sercom_index), (uint32_t)_sercom_handlers[sercom_index]);
#endif
/* Set the SERCOM in SPI master mode */
_SPI(obj).CTRLA.reg |= SERCOM_SPI_CTRLA_MODE(0x3);
pSPI_S(obj)->mode = SPI_MODE_MASTER;
/* TODO: Do pin muxing here */
struct system_pinmux_config pin_conf;
system_pinmux_get_config_defaults(&pin_conf);
pin_conf.direction = SYSTEM_PINMUX_PIN_DIR_INPUT;
uint32_t pad_pinmuxes[] = {
EXT1_SPI_SERCOM_PINMUX_PAD0, EXT1_SPI_SERCOM_PINMUX_PAD1,
EXT1_SPI_SERCOM_PINMUX_PAD2, EXT1_SPI_SERCOM_PINMUX_PAD3
};
/* Configure the SERCOM pins according to the user configuration */
for (uint8_t pad = 0; pad < 4; pad++) {
uint32_t current_pinmux = pad_pinmuxes[pad];
if (current_pinmux != PINMUX_UNUSED) {
pin_conf.mux_position = current_pinmux & 0xFFFF;
system_pinmux_pin_set_config(current_pinmux >> 16, &pin_conf);
}
}
void serial_init(serial_t *obj, PinName tx, PinName rx)
{
/* Sanity check arguments */
MBED_ASSERT(obj);
if (g_sys_init == 0) {
system_init();
g_sys_init = 1;
}
struct system_gclk_chan_config gclk_chan_conf;
UARTName uart;
uint32_t gclk_index;
uint32_t pm_index;
uint32_t sercom_index = 0;
uint32_t muxsetting = 0;
get_default_serial_values(obj);
pSERIAL_S(obj)->pins[USART_TX_INDEX] = tx;
pSERIAL_S(obj)->pins[USART_RX_INDEX] = rx;
pSERIAL_S(obj)->pins[USART_RXFLOW_INDEX] = NC;
pSERIAL_S(obj)->pins[USART_TXFLOW_INDEX] = NC;
muxsetting = serial_find_mux_settings(obj); // getting mux setting from pins
sercom_index = pinmap_merge_sercom(tx, rx); // same variable sercom_index reused for optimization
if (sercom_index == (uint32_t)NC) {
/*expecting a valid value for sercom index*/
return;
}
sercom_index &= 0x0F;
uart = (UARTName)pinmap_peripheral_sercom(NC, sercom_index);
pUSART_S(obj) = (Sercom *)uart;
/* Disable USART module */
disable_usart(obj);
#if (SAML21) || (SAMC20) || (SAMC21)
#if (SAML21)
if (sercom_index == 5) {
pm_index = MCLK_APBDMASK_SERCOM5_Pos;
gclk_index = SERCOM5_GCLK_ID_CORE;
} else {
pm_index = sercom_index + MCLK_APBCMASK_SERCOM0_Pos;
gclk_index = sercom_index + SERCOM0_GCLK_ID_CORE;
}
#else
pm_index = sercom_index + MCLK_APBCMASK_SERCOM0_Pos;
gclk_index = sercom_index + SERCOM0_GCLK_ID_CORE;
#endif
#else
pm_index = sercom_index + PM_APBCMASK_SERCOM0_Pos;
gclk_index = sercom_index + SERCOM0_GCLK_ID_CORE;
#endif
if (_USART(obj).CTRLA.reg & SERCOM_USART_CTRLA_SWRST) {
return; /* The module is busy resetting itself */
}
if (_USART(obj).CTRLA.reg & SERCOM_USART_CTRLA_ENABLE) {
return; /* Check the module is enabled */
}
/* Turn on module in PM */
#if (SAML21)
if (sercom_index == 5) {
system_apb_clock_set_mask(SYSTEM_CLOCK_APB_APBD, 1 << pm_index);
} else {
system_apb_clock_set_mask(SYSTEM_CLOCK_APB_APBC, 1 << pm_index);
}
#else
system_apb_clock_set_mask(SYSTEM_CLOCK_APB_APBC, 1 << pm_index);
#endif
/* Set up the GCLK for the module */
gclk_chan_conf.source_generator = GCLK_GENERATOR_0;
system_gclk_chan_set_config(gclk_index, &gclk_chan_conf);
system_gclk_chan_enable(gclk_index);
sercom_set_gclk_generator(GCLK_GENERATOR_0, false);
pSERIAL_S(obj)->mux_setting = muxsetting;
/* Set configuration according to the config struct */
usart_set_config_default(obj);
struct system_pinmux_config pin_conf;
pin_conf.direction = SYSTEM_PINMUX_PIN_DIR_INPUT;
pin_conf.input_pull = SYSTEM_PINMUX_PIN_PULL_NONE;
pin_conf.powersave = false;
/* Configure the SERCOM pins according to the user configuration */
for (uint8_t pad = 0; pad < 4; pad++) {
uint32_t current_pin = pSERIAL_S(obj)->pins[pad];
if (current_pin != (uint32_t)NC) {
pin_conf.mux_position = pinmap_function_sercom((PinName)current_pin, sercom_index);
if ((uint8_t)NC != pin_conf.mux_position) {
system_pinmux_pin_set_config(current_pin, &pin_conf);
}
}
}
if (uart == STDIO_UART) {
stdio_uart_inited = 1;
memcpy(&stdio_uart, obj, sizeof(serial_t));
}
/* Wait until synchronization is complete */
usart_syncing(obj);
/* Enable USART module */
enable_usart(obj);
}
