Devices/lilygo-tdeck/Source/devices/TdeckKeyboard.cpp

@@ -1,16 +1,13 @@
 #include "TdeckKeyboard.h"
-
-#include "../../../../TactilityKernel/include/tactility/drivers/i2c_controller.h"
-
-#include <KeyboardBacklight/KeyboardBacklight.h>
-#include <Tactility/Logger.h>
-#include <Tactility/hal/display/DisplayDevice.h>
 #include <Tactility/hal/i2c/I2c.h>
-#include <Tactility/settings/DisplaySettings.h>
-#include <Tactility/settings/KeyboardSettings.h>
 #include <driver/i2c.h>
 #include <lvgl.h>
+#include <Tactility/settings/KeyboardSettings.h>
+#include <Tactility/settings/DisplaySettings.h>
+#include <Tactility/hal/display/DisplayDevice.h>
 #include <tactility/hal/Device.h>
+#include <Tactility/Logger.h>
+#include <KeyboardBacklight/KeyboardBacklight.h>
 
 using tt::hal::findFirstDevice;
 
@@ -94,6 +91,5 @@ bool TdeckKeyboard::stopLvgl() {
 }
 
 bool TdeckKeyboard::isAttached() const {
-    auto controller = device_find_by_name("i2c_internal");
-    return i2c_controller_has_device_at_address(controller, TDECK_KEYBOARD_SLAVE_ADDRESS, 100) == ERROR_NONE;
+    return tt::hal::i2c::masterHasDeviceAtAddress(TDECK_KEYBOARD_I2C_BUS_HANDLE, TDECK_KEYBOARD_SLAVE_ADDRESS, 100);
 }

Devices/lilygo-tlora-pager/Source/devices/TpagerKeyboard.cpp

@@ -156,7 +156,7 @@ bool TpagerKeyboard::stopLvgl() {
 }
 
 bool TpagerKeyboard::isAttached() const {
-    return i2c_controller_has_device_at_address(keypad->getController(), keypad->getAddress(), 100) == ERROR_NONE;
+    return tt::hal::i2c::masterHasDeviceAtAddress(keypad->getPort(), keypad->getAddress(), 100);
 }
 
 bool TpagerKeyboard::initBacklight(gpio_num_t pin, uint32_t frequencyHz, ledc_timer_t timer, ledc_channel_t channel) {

Devices/m5stack-cores3/Source/devices/Display.cpp

@@ -11,8 +11,7 @@ static const auto LOGGER = tt::Logger("CoreS3Display");
 static void setBacklightDuty(uint8_t backlightDuty) {
     const uint8_t voltage = 20 + ((8 * backlightDuty) / 255); // [0b00000, 0b11100] - under 20 is too dark
     // TODO: Refactor to use Axp2102 driver subproject. Reference: https://github.com/m5stack/M5Unified/blob/b8cfec7fed046242da7f7b8024a4e92004a51ff7/src/utility/AXP2101_Class.cpp#L42
-    auto controller = device_find_by_name("i2c_internal");
-    if (i2c_controller_write_register(controller, AXP2101_ADDRESS, 0x99, &voltage, 1, 1000) != ERROR_NONE) { // Sets DLD01
+    if (!tt::hal::i2c::masterWriteRegister(I2C_NUM_0, AXP2101_ADDRESS, 0x99, &voltage, 1, 1000)) { // Sets DLD01
         LOGGER.error("Failed to set display backlight voltage");
     }
 }

Devices/m5stack-stackchan/Source/devices/Display.cpp

@@ -10,8 +10,7 @@ static const auto LOGGER = tt::Logger("StackChanDisplay");
 
 static void setBacklightDuty(uint8_t backlightDuty) {
     const uint8_t voltage = 20 + ((8 * backlightDuty) / 255); // [0b00000, 0b11100]
-    auto controller = device_find_by_name("i2c_internal");
-    if (i2c_controller_write_register(controller, AXP2101_ADDRESS, 0x99, &voltage, 1, 1000) != ERROR_NONE) { // Sets DLD01
+    if (!tt::hal::i2c::masterWriteRegister(I2C_NUM_0, AXP2101_ADDRESS, 0x99, &voltage, 1, 1000)) {
         LOGGER.error("Failed to set display backlight voltage");
     }
 }

Devices/m5stack-stackchan/m5stack,stackchan.dts

@@ -3,7 +3,6 @@
 #include <tactility/bindings/root.h>
 #include <tactility/bindings/esp32_ble.h>
 #include <tactility/bindings/esp32_gpio.h>
-#include <tactility/bindings/esp32_grove.h>
 #include <tactility/bindings/esp32_i2c.h>
 #include <tactility/bindings/esp32_i2s.h>
 #include <tactility/bindings/esp32_spi.h>

Platforms/platform-esp32/source/drivers/esp32_grove.cpp

@@ -168,13 +168,7 @@ static error_t start_device(Device* device) {
     if (!data) return ERROR_OUT_OF_MEMORY;
     device_set_driver_data(device, data);
 
-    if (start_child(device, config->defaultMode) != ERROR_NONE) {
-        device_set_driver_data(device, nullptr);
-        delete data;
-        return ERROR_RESOURCE;
-    }
-
-    return ERROR_NONE;
+    return start_child(device, config->defaultMode);
 }
 
 static error_t stop_device(Device* device) {

Tactility/Include/Tactility/hal/i2c/I2c.h

@@ -5,11 +5,60 @@
 
 #include <Tactility/freertoscompat/RTOS.h>
 
+#include <climits>
+#include <string>
+
 namespace tt::hal::i2c {
 
 constexpr TickType_t defaultTimeout = 10 / portTICK_PERIOD_MS;
 
+enum class Status {
+    Started,
+    Stopped,
+    Unknown
+};
+
+/** Start the bus for the specified port. */
+bool start(i2c_port_t port);
+
+/** Stop the bus for the specified port. */
+bool stop(i2c_port_t port);
+
+/** @return true if the bus is started */
+bool isStarted(i2c_port_t port);
+
+/** @return name or nullptr */
+const char* getName(i2c_port_t port);
+
+/** Read bytes in master mode. */
+bool masterRead(i2c_port_t port, uint8_t address, uint8_t* data, size_t dataSize, TickType_t timeout = defaultTimeout);
+
+/** Read bytes from the specified register in master mode. */
+bool masterReadRegister(i2c_port_t port, uint8_t address, uint8_t reg, uint8_t* data, size_t dataSize, TickType_t timeout = defaultTimeout);
+
+/** Write bytes in master mode. */
+bool masterWrite(i2c_port_t port, uint8_t address, const uint8_t* data, uint16_t dataSize, TickType_t timeout = defaultTimeout);
+
+/** Write bytes to a register in master mode */
+bool masterWriteRegister(i2c_port_t port, uint8_t address, uint8_t reg, const uint8_t* data, uint16_t dataSize, TickType_t timeout = defaultTimeout);
+
+/**
+ * Write multiple values to multiple registers in master mode.
+ * The input is as follows: { register1, value1, register2, value2, ... }
+ * @return false if any of the write operations failed
+ */
+bool masterWriteRegisterArray(i2c_port_t port, uint8_t address, const uint8_t* data, uint16_t dataSize, TickType_t timeout = defaultTimeout);
+
+/** Write bytes and then read the response bytes in master mode*/
+bool masterWriteRead(i2c_port_t port, uint8_t address, const uint8_t* writeData, size_t writeDataSize, uint8_t* readData, size_t readDataSize, TickType_t timeout = defaultTimeout);
+
 /** @return true when a device is detected at the specified address */
 bool masterHasDeviceAtAddress(i2c_port_t port, uint8_t address, TickType_t timeout = defaultTimeout);
 
+/**
+ * The lock for the specified bus.
+ * This can be used when calling native I2C functionality outside of Tactility.
+ */
+Lock& getLock(i2c_port_t port);
+
 } // namespace

Tactility/Source/hal/i2c/I2c.cpp

@@ -1,9 +1,11 @@
 #include <Tactility/hal/i2c/I2c.h>
 
+#include <Tactility/Logger.h>
 #include <Tactility/Mutex.h>
 
 #include <tactility/check.h>
 #include <tactility/drivers/i2c_controller.h>
+#include <tactility/time.h>
 
 #ifdef ESP_PLATFORM
 #include <tactility/drivers/esp32_i2c.h>
@@ -11,6 +13,13 @@
 
 namespace tt::hal::i2c {
 
+class NoLock final : public tt::Lock {
+    bool lock(TickType_t timeout) const override { return true; }
+    void unlock() const override { /* NO-OP */ }
+};
+
+static NoLock NO_LOCK;
+
 Device* findDevice(i2c_port_t port) {
 #ifdef ESP_PLATFORM
     struct Params {
@@ -28,7 +37,7 @@ Device* findDevice(i2c_port_t port) {
         auto* driver = device_get_driver(device);
         if (driver == nullptr) return true;
         if (!driver_is_compatible(driver, "espressif,esp32-i2c")) return true;
-        const auto* config = static_cast<const Esp32I2cConfig*>(device->config);
+        auto* config = static_cast<const Esp32I2cConfig*>(device->config);
         if (config->port != params_ptr->port) return true;
         // Found it, stop iterating
         params_ptr->device = device;
@@ -41,10 +50,62 @@ Device* findDevice(i2c_port_t port) {
 #endif
 }
 
+bool isStarted(i2c_port_t port) {
+    auto* device = findDevice(port);
+    if (device == nullptr) return false;
+    return device_is_ready(device);
+}
+
+const char* getName(i2c_port_t port) {
+    auto* device = findDevice(port);
+    if (device == nullptr) return nullptr;
+    return device->name;
+}
+
+bool masterRead(i2c_port_t port, uint8_t address, uint8_t* data, size_t dataSize, TickType_t timeout) {
+    auto* device = findDevice(port);
+    if (device == nullptr) return false;
+    return i2c_controller_read(device, address, data, dataSize, timeout) == ERROR_NONE;
+}
+
+bool masterReadRegister(i2c_port_t port, uint8_t address, uint8_t reg, uint8_t* data, size_t dataSize, TickType_t timeout) {
+    auto* device = findDevice(port);
+    if (device == nullptr) return false;
+    return i2c_controller_read_register(device, address, reg, data, dataSize, timeout) == ERROR_NONE;
+}
+
+bool masterWrite(i2c_port_t port, uint8_t address, const uint8_t* data, uint16_t dataSize, TickType_t timeout) {
+    auto* device = findDevice(port);
+    if (device == nullptr) return false;
+    return i2c_controller_write(device, address, data, dataSize, timeout) == ERROR_NONE;
+}
+
+bool masterWriteRegister(i2c_port_t port, uint8_t address, uint8_t reg, const uint8_t* data, uint16_t dataSize, TickType_t timeout) {
+    auto* device = findDevice(port);
+    if (device == nullptr) return false;
+    return i2c_controller_write_register(device, address, reg, data, dataSize, timeout) == ERROR_NONE;
+}
+
+bool masterWriteRegisterArray(i2c_port_t port, uint8_t address, const uint8_t* data, uint16_t dataSize, TickType_t timeout) {
+    auto* device = findDevice(port);
+    if (device == nullptr) return false;
+    return i2c_controller_write_register_array(device, address, data, dataSize, timeout) == ERROR_NONE;
+}
+
+bool masterWriteRead(i2c_port_t port, uint8_t address, const uint8_t* writeData, size_t writeDataSize, uint8_t* readData, size_t readDataSize, TickType_t timeout) {
+    auto* device = findDevice(port);
+    if (device == nullptr) return false;
+    return i2c_controller_write_read(device, address, writeData, writeDataSize, readData, readDataSize, timeout) == ERROR_NONE;
+}
+
 bool masterHasDeviceAtAddress(i2c_port_t port, uint8_t address, TickType_t timeout) {
     auto* device = findDevice(port);
     if (device == nullptr) return false;
     return i2c_controller_has_device_at_address(device, address, timeout) == ERROR_NONE;
 }
 
+Lock& getLock(i2c_port_t port) {
+    return NO_LOCK;
+}
+
 } // namespace