/* * @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; }