/*
* @fn nm_bus_init
* @brief Initialize the bus wrapper
* @return M2M_SUCCESS in case of success and M2M_ERR_BUS_FAIL in case of failure
*/
sint8 nm_bus_init(void *pvinit)
{
sint8 result = M2M_SUCCESS;
#ifdef CONF_WINC_USE_I2C
/* Not implemented */
#elif defined CONF_WINC_USE_SPI
/* Configure pins */
ioport_configure_pin(CONF_WIFI_M2M_SPI_CS_PIN, IOPORT_INIT_HIGH | IOPORT_DIR_OUTPUT);
ioport_configure_pin(CONF_WIFI_M2M_SPI_MOSI_PIN, IOPORT_INIT_HIGH | IOPORT_DIR_OUTPUT);
ioport_configure_pin(CONF_WIFI_M2M_SPI_MISO_PIN, IOPORT_DIR_INPUT);
ioport_configure_pin(CONF_WIFI_M2M_SPI_SCK_PIN, IOPORT_INIT_LOW | IOPORT_DIR_OUTPUT);
struct spi_device spi_device_conf;
spi_device_conf.id = CONF_WIFI_M2M_SPI_CS_PIN;
/* Configure the SPI master. */
spi_master_init(CONF_WIFI_M2M_SPI_MODULE);
spi_master_setup_device(CONF_WIFI_M2M_SPI_MODULE, &spi_device_conf, SPI_MODE_0, CONF_WIFI_M2M_SPI_BAUDRATE, 0);
/* Enable the SPI master. */
spi_enable(CONF_WIFI_M2M_SPI_MODULE);
nm_bsp_reset();
nm_bsp_sleep(1);
#endif
return result;
}
/*
* @fn nm_bus_init
* @brief Initialize the bus wrapper
* @return M2M_SUCCESS in case of success and M2M_ERR_BUS_FAIL in case of failure
*/
sint8 nm_bus_init(void *pvinit)
{
sint8 result = M2M_SUCCESS;
SPI_DEASSERT_CS();
// SPI configuration
SPI_HANDLE.Instance = SPI2;
SPI_HANDLE.Init.Mode = SPI_MODE_MASTER;
SPI_HANDLE.Init.Direction = SPI_DIRECTION_2LINES;
SPI_HANDLE.Init.DataSize = SPI_DATASIZE_8BIT;
SPI_HANDLE.Init.CLKPolarity = SPI_POLARITY_LOW;
SPI_HANDLE.Init.CLKPhase = SPI_PHASE_1EDGE;
SPI_HANDLE.Init.NSS = SPI_NSS_SOFT;
SPI_HANDLE.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2;
SPI_HANDLE.Init.FirstBit = SPI_FIRSTBIT_MSB;
SPI_HANDLE.Init.TIMode = SPI_TIMODE_DISABLED;
SPI_HANDLE.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLED;
SPI_HANDLE.Init.CRCPolynomial = 7;
// Init SPI
spi_init(&SPI_HANDLE, false);
nm_bsp_reset();
SPI_DEASSERT_CS();
return result;
}
sint8
nm_bus_init(void *pvinit)
{
struct hal_spi_settings cfg = { 0 };
/*
* Add code to configure spi.
*/
if (!winc1500_spi_inited) {
if (hal_gpio_init_out(WINC1500_SPI_SSN, 1)) {
return M2M_ERR_BUS_FAIL;
}
cfg.data_mode = HAL_SPI_MODE0;
cfg.data_order = HAL_SPI_MSB_FIRST;
cfg.word_size = HAL_SPI_WORD_SIZE_8BIT;
cfg.baudrate = WINC1500_SPI_SPEED;
if (hal_spi_config(BSP_WINC1500_SPI_PORT, &cfg)) {
return M2M_ERR_BUS_FAIL;
}
winc1500_spi_inited = 1;
if (hal_spi_enable(BSP_WINC1500_SPI_PORT)) {
return M2M_ERR_BUS_FAIL;
}
}
nm_bsp_reset();
nm_bsp_sleep(1);
return M2M_SUCCESS;
}
/*
* @fn nm_bsp_init
* @brief Initialize BSP
* @return 0 in case of success and -1 in case of failure
* @author M.S.M
* @date 11 July 2012
* @version 1.0
*/
sint8 nm_bsp_init(void)
{
gpfIsr = NULL;
init_chip_pins();
nm_bsp_reset();
return M2M_SUCCESS;
}
/*
* @fn nm_bsp_init
* @brief Initialize BSP
* @return 0 in case of success and -1 in case of failure
*/
sint8 nm_bsp_init(void)
{
gpfIsr = NULL;
/* Initialize chip IOs. */
init_chip_pins();
/* Perform chip reset. */
nm_bsp_reset();
return 0;
}
/*
* @fn nm_bus_init
* @brief Initialize the bus wrapper
* @return M2M_SUCCESS in case of success and M2M_ERR_BUS_FAIL in case of failure
*/
sint8 nm_bus_init(void *pvinit)
{
sint8 result = M2M_SUCCESS;
#ifdef CONF_WINC_USE_I2C
twihs_options_t opt;
/* Enable the peripheral clock for TWI */
pmc_enable_periph_clk(CONF_WINC_I2C_ID);
/* Configure the options of TWI driver */
opt.master_clk = sysclk_get_peripheral_hz();
opt.speed = CONF_WINC_TWIHS_CLOCK;
if (twihs_master_init(CONF_WINC_I2C, &opt) != TWIHS_SUCCESS) {
M2M_ERR("-E-\tTWI master initialization failed.\r");
while (1) {
/* Capture error */
}
}
#elif CONF_WINC_USE_SPI
/* Configure SPI pins. */
ioport_set_pin_mode(CONF_WINC_SPI_MISO_GPIO, CONF_WINC_SPI_MISO_FLAGS);
ioport_set_pin_mode(CONF_WINC_SPI_MOSI_GPIO, CONF_WINC_SPI_MOSI_FLAGS);
ioport_set_pin_mode(CONF_WINC_SPI_CLK_GPIO, CONF_WINC_SPI_CLK_FLAGS);
ioport_set_pin_mode(CONF_WINC_SPI_CS_GPIO, CONF_WINC_SPI_CS_FLAGS);
ioport_disable_pin(CONF_WINC_SPI_MISO_GPIO);
ioport_disable_pin(CONF_WINC_SPI_MOSI_GPIO);
ioport_disable_pin(CONF_WINC_SPI_CLK_GPIO);
ioport_disable_pin(CONF_WINC_SPI_CS_GPIO);
spi_enable_clock(CONF_WINC_SPI);
spi_disable(CONF_WINC_SPI);
spi_reset(CONF_WINC_SPI);
spi_set_master_mode(CONF_WINC_SPI);
spi_disable_mode_fault_detect(CONF_WINC_SPI);
spi_set_peripheral_chip_select_value(CONF_WINC_SPI, CONF_WINC_SPI_NPCS);
spi_set_clock_polarity(CONF_WINC_SPI,
CONF_WINC_SPI_NPCS, CONF_WINC_SPI_POL);
spi_set_clock_phase(CONF_WINC_SPI, CONF_WINC_SPI_NPCS, CONF_WINC_SPI_PHA);
spi_set_bits_per_transfer(CONF_WINC_SPI, CONF_WINC_SPI_NPCS, SPI_CSR_BITS_8_BIT);
spi_set_baudrate_div(CONF_WINC_SPI, CONF_WINC_SPI_NPCS,
(sysclk_get_cpu_hz() / CONF_WINC_SPI_CLOCK));
spi_set_transfer_delay(CONF_WINC_SPI, CONF_WINC_SPI_NPCS, CONF_WINC_SPI_DLYBS,
CONF_WINC_SPI_DLYBCT);
spi_enable(CONF_WINC_SPI);
nm_bsp_reset();
#endif
return result;
}
/*
* @fn nm_bus_init
* @brief Initialize the bus wrapper
* @return M2M_SUCCESS in case of success and M2M_ERR_BUS_FAIL in case of failure
*/
sint8 nm_bus_init(void *pvinit)
{
sint8 result = M2M_SUCCESS;
#ifdef CONF_WINC_USE_I2C
/* Initialize config structure and software module. */
struct i2c_master_config config_i2c_master;
i2c_master_get_config_defaults(&config_i2c_master);
/* Change buffer timeout to something longer. */
config_i2c_master.buffer_timeout = 1000;
/* Initialize and enable device with config. */
i2c_master_init(&i2c_master_instance, SERCOM2, &config_i2c_master);
i2c_master_enable(&i2c_master_instance);
#elif defined CONF_WINC_USE_SPI
/* Structure for SPI configuration. */
struct spi_config config;
struct spi_slave_inst_config slave_config;
/* Select SPI slave CS pin. */
/* This step will set the CS high */
spi_slave_inst_get_config_defaults(&slave_config);
slave_config.ss_pin = CONF_WINC_SPI_CS_PIN;
spi_attach_slave(&slave_inst, &slave_config);
/* Configure the SPI master. */
spi_get_config_defaults(&config);
config.mux_setting = CONF_WINC_SPI_SERCOM_MUX;
config.pinmux_pad0 = CONF_WINC_SPI_PINMUX_PAD0;
config.pinmux_pad1 = CONF_WINC_SPI_PINMUX_PAD1;
config.pinmux_pad2 = CONF_WINC_SPI_PINMUX_PAD2;
config.pinmux_pad3 = CONF_WINC_SPI_PINMUX_PAD3;
config.master_slave_select_enable = false;
config.mode_specific.master.baudrate = CONF_WINC_SPI_CLOCK;
if (spi_init(&master, CONF_WINC_SPI_MODULE, &config) != STATUS_OK) {
return M2M_ERR_BUS_FAIL;
}
/* Enable the SPI master. */
spi_enable(&master);
nm_bsp_reset();
nm_bsp_sleep(1);
#endif
return result;
}
/*
* @fn nm_bsp_init
* @brief Initialize BSP
* @return 0 in case of success and -1 in case of failure
*/
sint8 nm_bsp_init(void)
{
gpfIsr = NULL;
/* Initialize chip IOs. */
init_chip_pins();
/* Make sure a 1ms Systick is configured. */
if (!(SysTick->CTRL & SysTick_CTRL_ENABLE_Msk && SysTick->CTRL & SysTick_CTRL_TICKINT_Msk)) {
delay_init();
}
/* Perform chip reset. */
nm_bsp_reset();
return 0;
}
/*
* @fn nm_bsp_init
* @brief Initialize BSP
* @return 0 in case of success and -1 in case of failure
*/
sint8 nm_bsp_init(void)
{
// gpfIsr = NULL;
/* Initialize chip IOs. */
init_chip_pins();
/* Make sure a 1ms Systick is configured. */
// if (!(SysTick->CTRL & SysTick_CTRL_ENABLE_Msk && SysTick->CTRL & SysTick_CTRL_TICKINT_Msk)) {
// delay_init();
// }
/* Perform chip reset. */
nm_bsp_reset();
//system_interrupt_enable_global();
return M2M_SUCCESS;
}
/*
* @fn nm_bsp_init
* @brief Initialize BSP
* @return 0 in case of success and -1 in case of failure
*/
sint8 nm_bsp_init(void)
{
gpfIsr = NULL;
/* Initialize chip IOs. */
init_chip_pins();
/* TODO: Set timer? */
/* Make sure a 1ms Systick is configured. */
/*
if (!(SysTick->CTRL & SysTick_CTRL_ENABLE_Msk && SysTick->CTRL & SysTick_CTRL_TICKINT_Msk)) {
delay_init();
}
*/
/* Perform chip reset. */
nm_bsp_reset();
/* Enable glabal interrupt */
sei();
return M2M_SUCCESS;
}
static s8_t spi_rw(u8_t *mosi, u8_t *miso, u16_t size)
{
const struct spi_buf buf_tx = {
.buf = mosi,
.len = size
};
const struct spi_buf_set tx = {
.buffers = &buf_tx,
.count = 1
};
const struct spi_buf buf_rx = {
.buf = miso,
.len = miso ? size : 0
};
const struct spi_buf_set rx = {
.buffers = &buf_rx,
.count = 1
};
if (spi_transceive(winc1500.spi, &winc1500.spi_cfg, &tx, &rx)) {
LOG_ERR("spi_transceive fail");
return M2M_ERR_BUS_FAIL;
}
return M2M_SUCCESS;
}
#endif
s8_t nm_bus_init(void *pvinit)
{
/* configure GPIOs */
winc1500.gpios = winc1500_configure_gpios();
#ifdef CONF_WINC_USE_I2C
/* Not implemented */
#elif defined CONF_WINC_USE_SPI
/* setup SPI device */
winc1500.spi = device_get_binding(DT_ATMEL_WINC1500_0_BUS_NAME);
if (!winc1500.spi) {
LOG_ERR("spi device binding");
return -1;
}
winc1500.spi_cfg.operation = SPI_WORD_SET(8) | SPI_TRANSFER_MSB;
winc1500.spi_cfg.frequency = DT_ATMEL_WINC1500_0_SPI_MAX_FREQUENCY;
winc1500.spi_cfg.slave = DT_ATMEL_WINC1500_0_BASE_ADDRESS;
#ifdef CONFIG_WIFI_WINC1500_GPIO_SPI_CS
cs_ctrl.gpio_dev = device_get_binding(
DT_ATMEL_WINC1500_0_CS_GPIO_CONTROLLER);
if (!cs_ctrl.gpio_dev) {
LOG_ERR("Unable to get GPIO SPI CS device");
return -ENODEV;
}
cs_ctrl.gpio_pin = DT_ATMEL_WINC1500_0_CS_GPIO_PIN;
cs_ctrl.delay = 0U;
winc1500.spi_cfg.cs = &cs_ctrl;
LOG_DBG("SPI GPIO CS configured on %s:%u",
DT_ATMEL_WINC1500_0_CS_GPIO_CONTROLLER,
DT_ATMEL_WINC1500_0_CS_GPIO_PIN);
#endif /* CONFIG_WIFI_WINC1500_GPIO_SPI_CS */
nm_bsp_reset();
nm_bsp_sleep(1);
nm_bsp_interrupt_ctrl(1);
LOG_DBG("NOTICE:DONE");
#endif
return 0;
}
s8_t nm_bus_ioctl(u8_t cmd, void *parameter)
{
sint8 ret = 0;
switch (cmd) {
#ifdef CONF_WINC_USE_I2C
case NM_BUS_IOCTL_R: {
struct nm_i2c_default *param =
(struct nm_i2c_default *)parameter;
ret = nm_i2c_read(param->buffer, param->size);
}
break;
case NM_BUS_IOCTL_W: {
struct nm_i2c_default *param =
(struct nm_i2c_default *)parameter;
ret = nm_i2c_write(param->buffer, param->size);
}
break;
case NM_BUS_IOCTL_W_SPECIAL: {
struct nm_i2c_special *param =
(struct nm_i2c_special *)parameter;
ret = nm_i2c_write_special(param->buffer1, param->size1,
param->buffer2, param->size2);
}
break;
#elif defined CONF_WINC_USE_SPI
case NM_BUS_IOCTL_RW: {
tstrNmSpiRw *param = (tstrNmSpiRw *)parameter;
ret = spi_rw(param->pu8InBuf, param->pu8OutBuf, param->u16Sz);
}
break;
#endif
default:
ret = -1;
M2M_ERR("ERROR:invalid ioclt cmd\n");
break;
}
return ret;
}
s8_t nm_bus_deinit(void)
{
return M2M_SUCCESS;
}
s8_t nm_bus_reinit(void *config)
{
return 0;
}
/*
* @fn nm_bus_init
* @brief Initialize the bus wrapper
* @return M2M_SUCCESS in case of success and M2M_ERR_BUS_FAIL in case of failure
*/
sint8 nm_bus_init(void *pvinit)
{
sint8 result = M2M_SUCCESS;
#ifdef CONF_WINC_USE_I2C
/* Initialize config structure and software module. */
struct i2c_master_config config_i2c_master;
i2c_master_get_config_defaults(&config_i2c_master);
/* Change buffer timeout to something longer. */
config_i2c_master.buffer_timeout = 1000;
/* Initialize and enable device with config. */
i2c_master_init(&i2c_master_instance, SERCOM2, &config_i2c_master);
i2c_master_enable(&i2c_master_instance);
#elif defined CONF_WINC_USE_SPI
// hspi1.Instance = SPI1;
// hspi1.Init.Mode = SPI_MODE_MASTER;
// hspi1.Init.Direction = SPI_DIRECTION_2LINES;
// hspi1.Init.DataSize = SPI_DATASIZE_8BIT;
// hspi1.Init.CLKPolarity = SPI_POLARITY_LOW;
// hspi1.Init.CLKPhase = SPI_PHASE_1EDGE;
// hspi1.Init.NSS = SPI_NSS_SOFT;
// hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4;
// hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;
// hspi1.Init.TIMode = SPI_TIMODE_DISABLED;
// hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLED;
// hspi1.Init.CRCPolynomial = 10;
/* Structure for SPI configuration. */
// struct spi_config config;
// struct spi_slave_inst_config slave_config;
// /* Select SPI slave CS pin. */
// /* This step will set the CS high */
// spi_slave_inst_get_config_defaults(&slave_config);
// slave_config.ss_pin = CONF_WINC_SPI_CS_PIN;
// spi_attach_slave(&slave_inst, &slave_config);
// /* Configure the SPI master. */
// spi_get_config_defaults(&config);
// config.mux_setting = CONF_WINC_SPI_SERCOM_MUX;
// config.pinmux_pad0 = CONF_WINC_SPI_PINMUX_PAD0;
// config.pinmux_pad1 = CONF_WINC_SPI_PINMUX_PAD1;
// config.pinmux_pad2 = CONF_WINC_SPI_PINMUX_PAD2;
// config.pinmux_pad3 = CONF_WINC_SPI_PINMUX_PAD3;
// config.master_slave_select_enable = false;
// config.mode_specific.master.baudrate = CONF_WINC_SPI_CLOCK;
// if (spi_init(&master, CONF_WINC_SPI_MODULE, &config) != STATUS_OK) {
// return M2M_ERR_BUS_FAIL;
// }
// /* Enable the SPI master. */
// spi_enable(&master);
nm_bsp_reset();
nm_bsp_sleep(1);
#endif
return result;
}
