| /* |
| * Copyright (c) 2018, Nordic Semiconductor ASA |
| * |
| * SPDX-License-Identifier: Apache-2.0 |
| */ |
| |
| |
| #include <zephyr/drivers/i2c.h> |
| #include <zephyr/dt-bindings/i2c/i2c.h> |
| #include <zephyr/pm/device.h> |
| #include <zephyr/drivers/pinctrl.h> |
| #include <soc.h> |
| #include <nrfx_twi.h> |
| |
| #include <zephyr/logging/log.h> |
| #include <zephyr/irq.h> |
| LOG_MODULE_REGISTER(i2c_nrfx_twi, CONFIG_I2C_LOG_LEVEL); |
| |
| #if CONFIG_I2C_NRFX_TRANSFER_TIMEOUT |
| #define I2C_TRANSFER_TIMEOUT_MSEC K_MSEC(CONFIG_I2C_NRFX_TRANSFER_TIMEOUT) |
| #else |
| #define I2C_TRANSFER_TIMEOUT_MSEC K_FOREVER |
| #endif |
| |
| struct i2c_nrfx_twi_data { |
| struct k_sem transfer_sync; |
| struct k_sem completion_sync; |
| volatile nrfx_err_t res; |
| uint32_t dev_config; |
| }; |
| |
| struct i2c_nrfx_twi_config { |
| nrfx_twi_t twi; |
| nrfx_twi_config_t config; |
| const struct pinctrl_dev_config *pcfg; |
| }; |
| |
| static int i2c_nrfx_twi_recover_bus(const struct device *dev); |
| |
| static int i2c_nrfx_twi_transfer(const struct device *dev, |
| struct i2c_msg *msgs, |
| uint8_t num_msgs, uint16_t addr) |
| { |
| const struct i2c_nrfx_twi_config *config = dev->config; |
| struct i2c_nrfx_twi_data *data = dev->data; |
| int ret = 0; |
| |
| k_sem_take(&data->transfer_sync, K_FOREVER); |
| |
| /* Dummy take on completion_sync sem to be sure that it is empty */ |
| k_sem_take(&data->completion_sync, K_NO_WAIT); |
| |
| nrfx_twi_enable(&config->twi); |
| |
| for (size_t i = 0; i < num_msgs; i++) { |
| if (I2C_MSG_ADDR_10_BITS & msgs[i].flags) { |
| ret = -ENOTSUP; |
| break; |
| } |
| |
| nrfx_twi_xfer_desc_t cur_xfer = { |
| .p_primary_buf = msgs[i].buf, |
| .primary_length = msgs[i].len, |
| .address = addr, |
| .type = (msgs[i].flags & I2C_MSG_READ) ? |
| NRFX_TWI_XFER_RX : NRFX_TWI_XFER_TX |
| }; |
| uint32_t xfer_flags = 0; |
| nrfx_err_t res; |
| |
| /* In case the STOP condition is not supposed to appear after |
| * the current message, check what is requested further: |
| */ |
| if (!(msgs[i].flags & I2C_MSG_STOP)) { |
| /* - if the transfer consists of more messages |
| * and the I2C repeated START is not requested |
| * to appear before the next message, suspend |
| * the transfer after the current message, |
| * so that it can be resumed with the next one, |
| * resulting in the two messages merged into |
| * a continuous transfer on the bus |
| */ |
| if ((i < (num_msgs - 1)) && |
| !(msgs[i + 1].flags & I2C_MSG_RESTART)) { |
| xfer_flags |= NRFX_TWI_FLAG_SUSPEND; |
| /* - otherwise, just finish the transfer without |
| * generating the STOP condition, unless the current |
| * message is an RX request, for which such feature |
| * is not supported |
| */ |
| } else if (msgs[i].flags & I2C_MSG_READ) { |
| ret = -ENOTSUP; |
| break; |
| } else { |
| xfer_flags |= NRFX_TWI_FLAG_TX_NO_STOP; |
| } |
| } |
| |
| res = nrfx_twi_xfer(&config->twi, &cur_xfer, xfer_flags); |
| if (res != NRFX_SUCCESS) { |
| if (res == NRFX_ERROR_BUSY) { |
| ret = -EBUSY; |
| break; |
| } else { |
| ret = -EIO; |
| break; |
| } |
| } |
| |
| ret = k_sem_take(&data->completion_sync, |
| I2C_TRANSFER_TIMEOUT_MSEC); |
| if (ret != 0) { |
| /* Whatever the frequency, completion_sync should have |
| * been given by the event handler. |
| * |
| * If it hasn't, it's probably due to an hardware issue |
| * on the I2C line, for example a short between SDA and |
| * GND. |
| * This is issue has also been when trying to use the |
| * I2C bus during MCU internal flash erase. |
| * |
| * In many situation, a retry is sufficient. |
| * However, some time the I2C device get stuck and need |
| * help to recover. |
| * Therefore we always call i2c_nrfx_twi_recover_bus() |
| * to make sure everything has been done to restore the |
| * bus from this error. |
| */ |
| LOG_ERR("Error on I2C line occurred for message %d", i); |
| nrfx_twi_disable(&config->twi); |
| (void)i2c_nrfx_twi_recover_bus(dev); |
| ret = -EIO; |
| break; |
| } |
| |
| res = data->res; |
| if (res != NRFX_SUCCESS) { |
| LOG_ERR("Error 0x%08X occurred for message %d", res, i); |
| ret = -EIO; |
| break; |
| } |
| } |
| |
| nrfx_twi_disable(&config->twi); |
| k_sem_give(&data->transfer_sync); |
| |
| return ret; |
| } |
| |
| static void event_handler(nrfx_twi_evt_t const *p_event, void *p_context) |
| { |
| struct i2c_nrfx_twi_data *dev_data = p_context; |
| |
| switch (p_event->type) { |
| case NRFX_TWI_EVT_DONE: |
| dev_data->res = NRFX_SUCCESS; |
| break; |
| case NRFX_TWI_EVT_ADDRESS_NACK: |
| dev_data->res = NRFX_ERROR_DRV_TWI_ERR_ANACK; |
| break; |
| case NRFX_TWI_EVT_DATA_NACK: |
| dev_data->res = NRFX_ERROR_DRV_TWI_ERR_DNACK; |
| break; |
| default: |
| dev_data->res = NRFX_ERROR_INTERNAL; |
| break; |
| } |
| |
| k_sem_give(&dev_data->completion_sync); |
| } |
| |
| static int i2c_nrfx_twi_configure(const struct device *dev, |
| uint32_t dev_config) |
| { |
| const struct i2c_nrfx_twi_config *config = dev->config; |
| struct i2c_nrfx_twi_data *data = dev->data; |
| nrfx_twi_t const *inst = &config->twi; |
| |
| if (I2C_ADDR_10_BITS & dev_config) { |
| return -EINVAL; |
| } |
| |
| switch (I2C_SPEED_GET(dev_config)) { |
| case I2C_SPEED_STANDARD: |
| nrf_twi_frequency_set(inst->p_twi, NRF_TWI_FREQ_100K); |
| break; |
| case I2C_SPEED_FAST: |
| nrf_twi_frequency_set(inst->p_twi, NRF_TWI_FREQ_400K); |
| break; |
| default: |
| LOG_ERR("unsupported speed"); |
| return -EINVAL; |
| } |
| data->dev_config = dev_config; |
| |
| return 0; |
| } |
| |
| static int i2c_nrfx_twi_recover_bus(const struct device *dev) |
| { |
| const struct i2c_nrfx_twi_config *config = dev->config; |
| uint32_t scl_pin; |
| uint32_t sda_pin; |
| nrfx_err_t err; |
| |
| scl_pin = nrf_twi_scl_pin_get(config->twi.p_twi); |
| sda_pin = nrf_twi_sda_pin_get(config->twi.p_twi); |
| |
| err = nrfx_twi_bus_recover(scl_pin, sda_pin); |
| return (err == NRFX_SUCCESS ? 0 : -EBUSY); |
| } |
| |
| static const struct i2c_driver_api i2c_nrfx_twi_driver_api = { |
| .configure = i2c_nrfx_twi_configure, |
| .transfer = i2c_nrfx_twi_transfer, |
| .recover_bus = i2c_nrfx_twi_recover_bus, |
| }; |
| |
| static int init_twi(const struct device *dev) |
| { |
| const struct i2c_nrfx_twi_config *config = dev->config; |
| struct i2c_nrfx_twi_data *dev_data = dev->data; |
| nrfx_err_t result = nrfx_twi_init(&config->twi, &config->config, |
| event_handler, dev_data); |
| if (result != NRFX_SUCCESS) { |
| LOG_ERR("Failed to initialize device: %s", |
| dev->name); |
| return -EBUSY; |
| } |
| |
| return 0; |
| } |
| |
| #ifdef CONFIG_PM_DEVICE |
| static int twi_nrfx_pm_action(const struct device *dev, |
| enum pm_device_action action) |
| { |
| const struct i2c_nrfx_twi_config *config = dev->config; |
| struct i2c_nrfx_twi_data *data = dev->data; |
| int ret = 0; |
| |
| switch (action) { |
| case PM_DEVICE_ACTION_RESUME: |
| ret = pinctrl_apply_state(config->pcfg, PINCTRL_STATE_DEFAULT); |
| if (ret < 0) { |
| return ret; |
| } |
| init_twi(dev); |
| if (data->dev_config) { |
| i2c_nrfx_twi_configure(dev, data->dev_config); |
| } |
| break; |
| |
| case PM_DEVICE_ACTION_SUSPEND: |
| nrfx_twi_uninit(&config->twi); |
| |
| ret = pinctrl_apply_state(config->pcfg, PINCTRL_STATE_SLEEP); |
| if (ret < 0) { |
| return ret; |
| } |
| break; |
| |
| default: |
| ret = -ENOTSUP; |
| } |
| |
| return ret; |
| } |
| #endif /* CONFIG_PM_DEVICE */ |
| |
| #define I2C_NRFX_TWI_INVALID_FREQUENCY ((nrf_twi_frequency_t)-1) |
| #define I2C_NRFX_TWI_FREQUENCY(bitrate) \ |
| (bitrate == I2C_BITRATE_STANDARD ? NRF_TWI_FREQ_100K \ |
| : bitrate == 250000 ? NRF_TWI_FREQ_250K \ |
| : bitrate == I2C_BITRATE_FAST ? NRF_TWI_FREQ_400K \ |
| : I2C_NRFX_TWI_INVALID_FREQUENCY) |
| #define I2C(idx) DT_NODELABEL(i2c##idx) |
| #define I2C_FREQUENCY(idx) \ |
| I2C_NRFX_TWI_FREQUENCY(DT_PROP(I2C(idx), clock_frequency)) |
| |
| #define I2C_NRFX_TWI_DEVICE(idx) \ |
| NRF_DT_CHECK_NODE_HAS_PINCTRL_SLEEP(I2C(idx)); \ |
| BUILD_ASSERT(I2C_FREQUENCY(idx) != \ |
| I2C_NRFX_TWI_INVALID_FREQUENCY, \ |
| "Wrong I2C " #idx " frequency setting in dts"); \ |
| static int twi_##idx##_init(const struct device *dev) \ |
| { \ |
| IRQ_CONNECT(DT_IRQN(I2C(idx)), DT_IRQ(I2C(idx), priority), \ |
| nrfx_isr, nrfx_twi_##idx##_irq_handler, 0); \ |
| const struct i2c_nrfx_twi_config *config = dev->config; \ |
| int err = pinctrl_apply_state(config->pcfg, \ |
| PINCTRL_STATE_DEFAULT); \ |
| if (err < 0) { \ |
| return err; \ |
| } \ |
| return init_twi(dev); \ |
| } \ |
| static struct i2c_nrfx_twi_data twi_##idx##_data = { \ |
| .transfer_sync = Z_SEM_INITIALIZER( \ |
| twi_##idx##_data.transfer_sync, 1, 1), \ |
| .completion_sync = Z_SEM_INITIALIZER( \ |
| twi_##idx##_data.completion_sync, 0, 1) \ |
| }; \ |
| PINCTRL_DT_DEFINE(I2C(idx)); \ |
| static const struct i2c_nrfx_twi_config twi_##idx##z_config = { \ |
| .twi = NRFX_TWI_INSTANCE(idx), \ |
| .config = { \ |
| .skip_gpio_cfg = true, \ |
| .skip_psel_cfg = true, \ |
| .frequency = I2C_FREQUENCY(idx), \ |
| }, \ |
| .pcfg = PINCTRL_DT_DEV_CONFIG_GET(I2C(idx)), \ |
| }; \ |
| PM_DEVICE_DT_DEFINE(I2C(idx), twi_nrfx_pm_action); \ |
| I2C_DEVICE_DT_DEFINE(I2C(idx), \ |
| twi_##idx##_init, \ |
| PM_DEVICE_DT_GET(I2C(idx)), \ |
| &twi_##idx##_data, \ |
| &twi_##idx##z_config, \ |
| POST_KERNEL, \ |
| CONFIG_I2C_INIT_PRIORITY, \ |
| &i2c_nrfx_twi_driver_api) |
| |
| #ifdef CONFIG_I2C_0_NRF_TWI |
| I2C_NRFX_TWI_DEVICE(0); |
| #endif |
| |
| #ifdef CONFIG_I2C_1_NRF_TWI |
| I2C_NRFX_TWI_DEVICE(1); |
| #endif |