From 8e1ec63c99ec0a3187dc7bc31bcef7ba9236794f Mon Sep 17 00:00:00 2001 From: robin Date: Fri, 13 Sep 2024 13:10:59 +0200 Subject: [PATCH] Implement new idf-v5 I2C driver (#677) * moved sccb to new i2c driver * implemented val16 functions * address to dev_handle translation * moved new i2c driver to a seperate file * removed old idf version warning --- CMakeLists.txt | 10 +- driver/sccb-ng.c | 358 +++++++++++++++++++++++++++++++++++++++++++++++ driver/sccb.c | 1 + 3 files changed, 368 insertions(+), 1 deletion(-) create mode 100755 driver/sccb-ng.c diff --git a/CMakeLists.txt b/CMakeLists.txt index a3c60fdfd6..9947ae802d 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -26,7 +26,6 @@ if(IDF_TARGET STREQUAL "esp32" OR IDF_TARGET STREQUAL "esp32s2" OR IDF_TARGET ST list(APPEND srcs driver/esp_camera.c driver/cam_hal.c - driver/sccb.c driver/sensor.c sensors/ov2640.c sensors/ov3660.c @@ -82,6 +81,15 @@ if(IDF_TARGET STREQUAL "esp32" OR IDF_TARGET STREQUAL "esp32s2" OR IDF_TARGET ST list(APPEND priv_requires esp_timer) endif() + # include the SCCB I2C driver + # this uses either the legacy I2C API or the newwer version from IDF v5.4 + # as this features a method to obtain the I2C driver from a port number + if (idf_version VERSION_GREATER_EQUAL "5.4") + list(APPEND srcs driver/sccb-ng.c) + else() + list(APPEND srcs driver/sccb.c) + endif() + endif() # CONFIG_ESP_ROM_HAS_JPEG_DECODE is available from IDF v4.4 but diff --git a/driver/sccb-ng.c b/driver/sccb-ng.c new file mode 100755 index 0000000000..0ea99659b3 --- /dev/null +++ b/driver/sccb-ng.c @@ -0,0 +1,358 @@ +/* + * This file is part of the OpenMV project. + * Copyright (c) 2013/2014 Ibrahim Abdelkader + * This work is licensed under the MIT license, see the file LICENSE for details. + * + * SCCB (I2C like) driver with the new esp-idf I2C API. + * + */ +#include +#include +#include +#include +#include "sccb.h" +#include "sensor.h" +#include +#include "sdkconfig.h" +#if defined(ARDUINO_ARCH_ESP32) && defined(CONFIG_ARDUHAL_ESP_LOG) +#include "esp32-hal-log.h" +#else +#include "esp_log.h" +static const char *TAG = "sccb-ng"; +#endif + +#define LITTLETOBIG(x) ((x << 8) | (x >> 8)) + +#include "esp_private/i2c_platform.h" +#include "driver/i2c_master.h" +#include "driver/i2c_types.h" + +// support IDF 5.x +#ifndef portTICK_RATE_MS +#define portTICK_RATE_MS portTICK_PERIOD_MS +#endif + +#define TIMEOUT_MS 1000 /*!< I2C timeout duration */ +#define SCCB_FREQ CONFIG_SCCB_CLK_FREQ /*!< I2C master frequency */ +#define WRITE_BIT I2C_MASTER_WRITE /*!< I2C master write */ +#define READ_BIT I2C_MASTER_READ /*!< I2C master read */ +#define ACK_CHECK_EN 0x1 /*!< I2C master will check ack from slave */ +#define ACK_CHECK_DIS 0x0 /*!< I2C master will not check ack from slave */ +#define ACK_VAL 0x0 /*!< I2C ack value */ +#define NACK_VAL 0x1 /*!< I2C nack value */ +#if CONFIG_SCCB_HARDWARE_I2C_PORT1 +const int SCCB_I2C_PORT_DEFAULT = 1; +#else +const int SCCB_I2C_PORT_DEFAULT = 0; +#endif + +#define MAX_DEVICES UINT8_MAX-1 + +/* + The legacy I2C driver used addresses to differentiate between devices, whereas the new driver uses + i2c_master_dev_handle_t structs which are registed to the bus. + To avoid re-writing all camera dependant code, we simply translate the devices address to the corresponding + device_handle. This keeps all interfaces to the drivers identical. + To perform this conversion the following local struct is used. +*/ +typedef struct +{ + i2c_master_dev_handle_t dev_handle; + uint16_t address; +} device_t; + +static device_t devices[MAX_DEVICES]; +static uint8_t device_count = 0; +static int sccb_i2c_port; +static bool sccb_owns_i2c_port; + +i2c_master_dev_handle_t *get_handle_from_address(uint8_t slv_addr) +{ + for (uint8_t i = 0; i < device_count; i++) + { + + if (slv_addr == devices[i].address) + { + return &(devices[i].dev_handle); + } + } + + ESP_LOGE(TAG, "Device with address %02x not found", slv_addr); + return NULL; +} + +int SCCB_Install_Device(uint8_t slv_addr) +{ + esp_err_t ret; + i2c_master_bus_handle_t bus_handle; + + if (device_count > MAX_DEVICES) + { + ESP_LOGE(TAG, "cannot add more than %d devices", MAX_DEVICES); + return ESP_FAIL; + } + + ret = i2c_master_get_bus_handle(sccb_i2c_port, &bus_handle); + if (ret != ESP_OK) + { + ESP_LOGE(TAG, "failed to get SCCB I2C Bus handle for port %d", sccb_i2c_port); + return ret; + } + + i2c_device_config_t dev_cfg = { + .dev_addr_length = I2C_ADDR_BIT_LEN_7, + .device_address = slv_addr, // not yet set + .scl_speed_hz = SCCB_FREQ, + }; + + ret = i2c_master_bus_add_device(bus_handle, &dev_cfg, &(devices[device_count].dev_handle)); + if (ret != ESP_OK) + { + ESP_LOGE(TAG, "failed to install SCCB I2C device: %s", esp_err_to_name(ret)); + return -1; + } + + devices[device_count].address = slv_addr; + device_count++; + return 0; +} + +int SCCB_Init(int pin_sda, int pin_scl) +{ + ESP_LOGI(TAG, "pin_sda %d pin_scl %d", pin_sda, pin_scl); + // i2c_config_t conf; + esp_err_t ret; + + sccb_i2c_port = SCCB_I2C_PORT_DEFAULT; + sccb_owns_i2c_port = true; + ESP_LOGI(TAG, "sccb_i2c_port=%d", sccb_i2c_port); + + i2c_master_bus_config_t i2c_mst_config = { + .clk_source = I2C_CLK_SRC_DEFAULT, + .i2c_port = SCCB_I2C_PORT_DEFAULT, + .scl_io_num = pin_scl, + .sda_io_num = pin_sda, + .glitch_ignore_cnt = 7, + .flags.enable_internal_pullup = 1}; + + i2c_master_bus_handle_t bus_handle; + ret = i2c_new_master_bus(&i2c_mst_config, &bus_handle); + + if (ret != ESP_OK) + { + ESP_LOGE(TAG, "failed to install SCCB I2C master bus on port %d: %s", sccb_i2c_port, esp_err_to_name(ret)); + return ret; + } + + return ESP_OK; +} + +int SCCB_Use_Port(int i2c_num) +{ // sccb use an already initialized I2C port + if (sccb_owns_i2c_port) + { + SCCB_Deinit(); + } + if (i2c_num < 0 || i2c_num > I2C_NUM_MAX) + { + return ESP_ERR_INVALID_ARG; + } + sccb_i2c_port = i2c_num; + + return ESP_OK; +} + +int SCCB_Deinit(void) +{ + esp_err_t ret; + + for (uint8_t i = 0; i < device_count; i++) + { + ret = i2c_master_bus_rm_device(devices[i].dev_handle); + if (ret != ESP_OK) + { + ESP_LOGE(TAG, "failed to remove SCCB I2C Device"); + return ret; + } + + devices[i].dev_handle = NULL; + devices[i].address = 0; + } + device_count = 0; + + if (!sccb_owns_i2c_port) + { + return ESP_OK; + } + sccb_owns_i2c_port = false; + + i2c_master_bus_handle_t bus_handle; + ret = i2c_master_get_bus_handle(sccb_i2c_port, &bus_handle); + if (ret != ESP_OK) + { + ESP_LOGE(TAG, "failed to get SCCB I2C Bus handle for port %d", sccb_i2c_port); + return ret; + } + + ret = i2c_del_master_bus(bus_handle); + if (ret != ESP_OK) + { + ESP_LOGE(TAG, "failed to get delete SCCB I2C Master Bus at port %d", sccb_i2c_port); + return ret; + } + + return ESP_OK; +} + +uint8_t SCCB_Probe(void) +{ + uint8_t slave_addr = 0x0; + esp_err_t ret; + i2c_master_bus_handle_t bus_handle; + + ret = i2c_master_get_bus_handle(sccb_i2c_port, &bus_handle); + if (ret != ESP_OK) + { + ESP_LOGE(TAG, "failed to get SCCB I2C Bus handle for port %d", sccb_i2c_port); + return ret; + } + + for (size_t i = 0; i < CAMERA_MODEL_MAX; i++) + { + if (slave_addr == camera_sensor[i].sccb_addr) + { + continue; + } + slave_addr = camera_sensor[i].sccb_addr; + + ret = i2c_master_probe(bus_handle, slave_addr, TIMEOUT_MS); + + if (ret == ESP_OK) + { + if (SCCB_Install_Device(slave_addr) != 0) + { + return 0; + } + return slave_addr; + } + } + return 0; +} + +uint8_t SCCB_Read(uint8_t slv_addr, uint8_t reg) +{ + i2c_master_dev_handle_t dev_handle = *(get_handle_from_address(slv_addr)); + + uint8_t tx_buffer[1]; + uint8_t rx_buffer[1]; + + tx_buffer[0] = reg; + + esp_err_t ret = i2c_master_transmit_receive(dev_handle, tx_buffer, 1, rx_buffer, 1, TIMEOUT_MS); + + if (ret != ESP_OK) + { + ESP_LOGE(TAG, "SCCB_Read Failed addr:0x%02x, reg:0x%02x, data:0x%02x, ret:%d", slv_addr, reg, rx_buffer[0], ret); + } + + return rx_buffer[0]; +} + +int SCCB_Write(uint8_t slv_addr, uint8_t reg, uint8_t data) +{ + i2c_master_dev_handle_t dev_handle = *(get_handle_from_address(slv_addr)); + + uint8_t tx_buffer[2]; + tx_buffer[0] = reg; + tx_buffer[1] = data; + + esp_err_t ret = i2c_master_transmit(dev_handle, tx_buffer, 2, TIMEOUT_MS); + + if (ret != ESP_OK) + { + ESP_LOGE(TAG, "SCCB_Write Failed addr:0x%02x, reg:0x%02x, data:0x%02x, ret:%d", slv_addr, reg, data, ret); + } + + return ret == ESP_OK ? 0 : -1; +} + +uint8_t SCCB_Read16(uint8_t slv_addr, uint16_t reg) +{ + i2c_master_dev_handle_t dev_handle = *(get_handle_from_address(slv_addr)); + + uint8_t rx_buffer[1]; + + uint16_t reg_htons = LITTLETOBIG(reg); + uint8_t *reg_u8 = (uint8_t *)®_htons; + + esp_err_t ret = i2c_master_transmit_receive(dev_handle, reg_u8, 2, rx_buffer, 1, TIMEOUT_MS); + + if (ret != ESP_OK) + { + ESP_LOGE(TAG, "W [%04x]=%02x fail\n", reg, rx_buffer[0]); + } + + return rx_buffer[0]; +} + +int SCCB_Write16(uint8_t slv_addr, uint16_t reg, uint8_t data) +{ + i2c_master_dev_handle_t dev_handle = *(get_handle_from_address(slv_addr)); + + uint16_t reg_htons = LITTLETOBIG(reg); + + uint8_t tx_buffer[3]; + tx_buffer[0] = reg_htons >> 8; + tx_buffer[1] = reg_htons & 0x00ff; + tx_buffer[2] = data; + + esp_err_t ret = i2c_master_transmit(dev_handle, tx_buffer, 3, TIMEOUT_MS); + + if (ret != ESP_OK) + { + ESP_LOGE(TAG, "W [%04x]=%02x fail\n", reg, data); + } + return ret == ESP_OK ? 0 : -1; +} + +uint16_t SCCB_Read_Addr16_Val16(uint8_t slv_addr, uint16_t reg) +{ + i2c_master_dev_handle_t dev_handle = *(get_handle_from_address(slv_addr)); + + uint8_t rx_buffer[2]; + + uint16_t reg_htons = LITTLETOBIG(reg); + uint8_t *reg_u8 = (uint8_t *)®_htons; + + esp_err_t ret = i2c_master_transmit_receive(dev_handle, reg_u8, 2, rx_buffer, 2, TIMEOUT_MS); + uint16_t data = ((uint16_t)rx_buffer[0] << 8) | (uint16_t)rx_buffer[1]; + + if (ret != ESP_OK) + { + ESP_LOGE(TAG, "W [%04x]=%02x fail\n", reg, data); + } + + return data; +} + +int SCCB_Write_Addr16_Val16(uint8_t slv_addr, uint16_t reg, uint16_t data) +{ + i2c_master_dev_handle_t dev_handle = *(get_handle_from_address(slv_addr)); + + uint16_t reg_htons = LITTLETOBIG(reg); + + uint8_t tx_buffer[4]; + tx_buffer[0] = reg_htons >> 8; + tx_buffer[1] = reg_htons & 0x00ff; + tx_buffer[2] = data >> 8; + tx_buffer[3] = data & 0x00ff; + + esp_err_t ret = i2c_master_transmit(dev_handle, tx_buffer, 4, TIMEOUT_MS); + + if (ret != ESP_OK) + { + ESP_LOGE(TAG, "W [%04x]=%02x fail\n", reg, data); + } + return ret == ESP_OK ? 0 : -1; + return 0; +} diff --git a/driver/sccb.c b/driver/sccb.c index 307166d0fb..7007883c15 100755 --- a/driver/sccb.c +++ b/driver/sccb.c @@ -6,6 +6,7 @@ * SCCB (I2C like) driver. * */ + #include #include #include