Ken Van Hoeylandt
193 lines
6.7 KiB
C++
193 lines
6.7 KiB
C++
// SPDX-License-Identifier: Apache-2.0
|
|
#include <soc/soc_caps.h>
|
|
#if SOC_LCD_I80_SUPPORTED
|
|
|
|
#include <tactility/device.h>
|
|
#include <tactility/drivers/esp32_i8080.h>
|
|
#include <tactility/log.h>
|
|
|
|
#include "tactility/drivers/gpio_descriptor.h"
|
|
#include <tactility/drivers/esp32_gpio_helpers.h>
|
|
#include <tactility/drivers/gpio_controller.h>
|
|
|
|
#include <esp_lcd_panel_io.h>
|
|
|
|
#include <new>
|
|
#include <vector>
|
|
|
|
#define TAG "esp32_i8080"
|
|
|
|
#define GET_CONFIG(device) ((const struct Esp32I8080Config*)device->config)
|
|
#define GET_DATA(device) ((struct Esp32I8080Internal*)device_get_driver_data(device))
|
|
|
|
extern "C" {
|
|
|
|
struct Esp32I8080Internal {
|
|
esp_lcd_i80_bus_handle_t bus_handle = nullptr;
|
|
|
|
GpioDescriptor* dc_descriptor = nullptr;
|
|
GpioDescriptor* wr_descriptor = nullptr;
|
|
GpioDescriptor* rd_descriptor = nullptr;
|
|
GpioDescriptor* d0_descriptor = nullptr;
|
|
GpioDescriptor* d1_descriptor = nullptr;
|
|
GpioDescriptor* d2_descriptor = nullptr;
|
|
GpioDescriptor* d3_descriptor = nullptr;
|
|
GpioDescriptor* d4_descriptor = nullptr;
|
|
GpioDescriptor* d5_descriptor = nullptr;
|
|
GpioDescriptor* d6_descriptor = nullptr;
|
|
GpioDescriptor* d7_descriptor = nullptr;
|
|
|
|
std::vector<GpioDescriptor*> cs_descriptors;
|
|
|
|
void cleanup_pins() {
|
|
release_pin(&dc_descriptor);
|
|
release_pin(&wr_descriptor);
|
|
release_pin(&rd_descriptor);
|
|
release_pin(&d0_descriptor);
|
|
release_pin(&d1_descriptor);
|
|
release_pin(&d2_descriptor);
|
|
release_pin(&d3_descriptor);
|
|
release_pin(&d4_descriptor);
|
|
release_pin(&d5_descriptor);
|
|
release_pin(&d6_descriptor);
|
|
release_pin(&d7_descriptor);
|
|
for (auto*& desc : cs_descriptors) {
|
|
release_pin(&desc);
|
|
}
|
|
cs_descriptors.clear();
|
|
}
|
|
};
|
|
|
|
static error_t start(Device* device) {
|
|
LOG_I(TAG, "start %s", device->name);
|
|
auto* data = new (std::nothrow) Esp32I8080Internal();
|
|
if (data == nullptr) return ERROR_OUT_OF_MEMORY;
|
|
|
|
device_set_driver_data(device, data);
|
|
|
|
const auto* config = GET_CONFIG(device);
|
|
|
|
bool pins_ok =
|
|
acquire_pin_or_set_null(config->pin_dc, &data->dc_descriptor) &&
|
|
acquire_pin_or_set_null(config->pin_wr, &data->wr_descriptor) &&
|
|
acquire_pin_or_set_null(config->pin_rd, &data->rd_descriptor) &&
|
|
acquire_pin_or_set_null(config->pin_d0, &data->d0_descriptor) &&
|
|
acquire_pin_or_set_null(config->pin_d1, &data->d1_descriptor) &&
|
|
acquire_pin_or_set_null(config->pin_d2, &data->d2_descriptor) &&
|
|
acquire_pin_or_set_null(config->pin_d3, &data->d3_descriptor) &&
|
|
acquire_pin_or_set_null(config->pin_d4, &data->d4_descriptor) &&
|
|
acquire_pin_or_set_null(config->pin_d5, &data->d5_descriptor) &&
|
|
acquire_pin_or_set_null(config->pin_d6, &data->d6_descriptor) &&
|
|
acquire_pin_or_set_null(config->pin_d7, &data->d7_descriptor);
|
|
|
|
if (!pins_ok) {
|
|
LOG_E(TAG, "Failed to acquire required i8080 pins");
|
|
data->cleanup_pins();
|
|
device_set_driver_data(device, nullptr);
|
|
delete data;
|
|
return ERROR_RESOURCE;
|
|
}
|
|
|
|
// RD is never toggled by the i80 LCD peripheral (write-only bus); drive it high once so the
|
|
// panel doesn't see spurious read strobes.
|
|
if (data->rd_descriptor != nullptr) {
|
|
gpio_descriptor_set_flags(data->rd_descriptor, GPIO_FLAG_DIRECTION_OUTPUT);
|
|
gpio_descriptor_set_level(data->rd_descriptor, true);
|
|
}
|
|
|
|
esp_lcd_i80_bus_config_t bus_cfg = {
|
|
.dc_gpio_num = get_native_pin(data->dc_descriptor),
|
|
.wr_gpio_num = get_native_pin(data->wr_descriptor),
|
|
.clk_src = LCD_CLK_SRC_DEFAULT,
|
|
.data_gpio_nums = {
|
|
get_native_pin(data->d0_descriptor),
|
|
get_native_pin(data->d1_descriptor),
|
|
get_native_pin(data->d2_descriptor),
|
|
get_native_pin(data->d3_descriptor),
|
|
get_native_pin(data->d4_descriptor),
|
|
get_native_pin(data->d5_descriptor),
|
|
get_native_pin(data->d6_descriptor),
|
|
get_native_pin(data->d7_descriptor),
|
|
},
|
|
.bus_width = 8,
|
|
.max_transfer_bytes = static_cast<size_t>(config->max_transfer_bytes),
|
|
.psram_trans_align = 64,
|
|
.sram_trans_align = 4
|
|
};
|
|
|
|
esp_err_t ret = esp_lcd_new_i80_bus(&bus_cfg, &data->bus_handle);
|
|
if (ret != ESP_OK) {
|
|
LOG_E(TAG, "Failed to create I80 bus: %s", esp_err_to_name(ret));
|
|
data->cleanup_pins();
|
|
device_set_driver_data(device, nullptr);
|
|
delete data;
|
|
return ERROR_RESOURCE;
|
|
}
|
|
|
|
// Acquire and deselect all CS pins (drive high)
|
|
for (uint8_t i = 0; i < config->cs_gpios_count; i++) {
|
|
const GpioPinSpec* cs = &config->cs_gpios[i];
|
|
if (cs->gpio_controller == nullptr) continue;
|
|
GpioDescriptor* desc = gpio_descriptor_acquire(cs->gpio_controller, cs->pin, GPIO_OWNER_GPIO);
|
|
if (desc != nullptr) {
|
|
gpio_descriptor_set_flags(desc, GPIO_FLAG_DIRECTION_OUTPUT);
|
|
gpio_descriptor_set_level(desc, true);
|
|
data->cs_descriptors.push_back(desc);
|
|
} else {
|
|
LOG_E(TAG, "Failed to acquire CS pin %u", i);
|
|
}
|
|
}
|
|
|
|
return ERROR_NONE;
|
|
}
|
|
|
|
static error_t stop(Device* device) {
|
|
LOG_I(TAG, "stop %s", device->name);
|
|
auto* data = GET_DATA(device);
|
|
|
|
if (data->bus_handle != nullptr) {
|
|
esp_lcd_del_i80_bus(data->bus_handle);
|
|
}
|
|
|
|
data->cleanup_pins();
|
|
device_set_driver_data(device, nullptr);
|
|
delete data;
|
|
return ERROR_NONE;
|
|
}
|
|
|
|
error_t esp32_i8080_get_cs_pin(Device* child_device, GpioPinSpec* out_pin) {
|
|
auto* parent = device_get_parent(child_device);
|
|
if (parent == nullptr || device_get_type(parent) != &I8080_CONTROLLER_TYPE) return ERROR_INVALID_STATE;
|
|
const auto* config = GET_CONFIG(parent);
|
|
int32_t index = child_device->address;
|
|
if (index < 0 || index >= config->cs_gpios_count) return ERROR_OUT_OF_RANGE;
|
|
*out_pin = config->cs_gpios[index];
|
|
return ERROR_NONE;
|
|
}
|
|
|
|
error_t esp32_i8080_get_bus_handle(Device* child_device, esp_lcd_i80_bus_handle_t* out_handle) {
|
|
auto* parent = device_get_parent(child_device);
|
|
if (parent == nullptr || device_get_type(parent) != &I8080_CONTROLLER_TYPE) return ERROR_INVALID_STATE;
|
|
auto* data = GET_DATA(parent);
|
|
if (data == nullptr || data->bus_handle == nullptr) return ERROR_INVALID_STATE;
|
|
*out_handle = data->bus_handle;
|
|
return ERROR_NONE;
|
|
}
|
|
|
|
extern struct Module platform_esp32_module;
|
|
|
|
Driver esp32_i8080_driver = {
|
|
.name = "esp32_i8080",
|
|
.compatible = (const char*[]) { "espressif,esp32-i8080", nullptr },
|
|
.start_device = start,
|
|
.stop_device = stop,
|
|
.api = nullptr,
|
|
.device_type = &I8080_CONTROLLER_TYPE,
|
|
.owner = &platform_esp32_module,
|
|
.internal = nullptr
|
|
};
|
|
|
|
} // extern "C"
|
|
|
|
#endif // SOC_LCD_I80_SUPPORTED
|