Crazypedia
226 lines
8.5 KiB
C++
226 lines
8.5 KiB
C++
#include "Cst66xxTouch.h"
|
|
|
|
#include <tactility/log.h>
|
|
#include <Tactility/app/App.h>
|
|
#include <tactility/drivers/gpio_controller.h>
|
|
#include <tactility/drivers/i2c_controller.h>
|
|
|
|
#include <freertos/FreeRTOS.h>
|
|
|
|
// Touch reset is wired to XL9555 P07 (active low).
|
|
static constexpr uint32_t XL9555_PIN_TOUCH_RST = 7;
|
|
|
|
constexpr auto* TAG = "CST66xx";
|
|
|
|
static constexpr TickType_t I2C_TIMEOUT = pdMS_TO_TICKS(20);
|
|
|
|
// The protocol uses 4-byte register addresses, taken from the vendor's
|
|
// lib/HynTouch/src/hyn_cst66xx.c.
|
|
|
|
// Normal-mode setup sequence (cst66xx_set_workmode, NOMAL_MODE).
|
|
static constexpr uint8_t CMD_DISABLE_LP_I2C[4] = {0xD0, 0x00, 0x04, 0x00};
|
|
static constexpr uint8_t CMD_NORMAL_A[4] = {0xD0, 0x00, 0x00, 0x00};
|
|
static constexpr uint8_t CMD_NORMAL_B[4] = {0xD0, 0x00, 0x0C, 0x00};
|
|
static constexpr uint8_t CMD_NORMAL_C[4] = {0xD0, 0x00, 0x01, 0x00};
|
|
// Read-point register: write these 4 bytes, then read the touch frame.
|
|
static constexpr uint8_t REG_READ_POINT[4] = {0xD0, 0x07, 0x00, 0x00};
|
|
// Acknowledge/clear after each read.
|
|
static constexpr uint8_t CMD_ACK[4] = {0xD0, 0x00, 0x02, 0xAB};
|
|
// Identity/config register (cst66xx_updata_tpinfo): read 50 bytes; buf[2]==0xCA
|
|
// && buf[3]==0xCA confirms a CST66xx.
|
|
static constexpr uint8_t REG_INFO[4] = {0xD0, 0x03, 0x00, 0x00};
|
|
|
|
static void setNormalMode(::Device* i2c, uint8_t address) {
|
|
i2c_controller_write(i2c, address, CMD_DISABLE_LP_I2C, sizeof(CMD_DISABLE_LP_I2C), I2C_TIMEOUT);
|
|
vTaskDelay(pdMS_TO_TICKS(1));
|
|
i2c_controller_write(i2c, address, CMD_DISABLE_LP_I2C, sizeof(CMD_DISABLE_LP_I2C), I2C_TIMEOUT);
|
|
i2c_controller_write(i2c, address, CMD_NORMAL_A, sizeof(CMD_NORMAL_A), I2C_TIMEOUT);
|
|
i2c_controller_write(i2c, address, CMD_NORMAL_B, sizeof(CMD_NORMAL_B), I2C_TIMEOUT);
|
|
i2c_controller_write(i2c, address, CMD_NORMAL_C, sizeof(CMD_NORMAL_C), I2C_TIMEOUT);
|
|
}
|
|
|
|
bool Cst66xxTouch::start() {
|
|
// Reset the controller (XL9555 P07, active low). The chip only re-initialises
|
|
// into normal reporting mode after a clean reset pulse.
|
|
auto* xl9555 = device_find_by_name("xl9555");
|
|
if (xl9555 != nullptr) {
|
|
auto* rst = gpio_descriptor_acquire(xl9555, XL9555_PIN_TOUCH_RST, GPIO_OWNER_GPIO);
|
|
if (rst != nullptr) {
|
|
gpio_descriptor_set_flags(rst, GPIO_FLAG_DIRECTION_OUTPUT);
|
|
gpio_descriptor_set_level(rst, false);
|
|
vTaskDelay(pdMS_TO_TICKS(10));
|
|
gpio_descriptor_set_level(rst, true);
|
|
gpio_descriptor_release(rst);
|
|
}
|
|
}
|
|
// The reset pulse exits boot mode; give the controller time to re-init.
|
|
vTaskDelay(pdMS_TO_TICKS(80));
|
|
|
|
// Put the controller into normal reporting mode and verify the identity. The
|
|
// first read after reset can miss, so retry like the vendor's
|
|
// cst66xx_updata_tpinfo (read 0xD0030000, expect buf[2]==buf[3]==0xCA).
|
|
auto* i2c = configuration.i2cController;
|
|
const uint8_t address = configuration.address;
|
|
bool confirmed = false;
|
|
for (int attempt = 0; attempt < 5 && !confirmed; ++attempt) {
|
|
setNormalMode(i2c, address);
|
|
uint8_t info[50] = {};
|
|
if (i2c_controller_write(i2c, address, REG_INFO, sizeof(REG_INFO), I2C_TIMEOUT) == ERROR_NONE &&
|
|
i2c_controller_read(i2c, address, info, sizeof(info), I2C_TIMEOUT) == ERROR_NONE &&
|
|
info[2] == 0xCA && info[3] == 0xCA) {
|
|
confirmed = true;
|
|
} else {
|
|
vTaskDelay(pdMS_TO_TICKS(10));
|
|
}
|
|
}
|
|
if (confirmed) {
|
|
LOG_I(TAG, "CST66xx initialised");
|
|
} else {
|
|
LOG_W(TAG, "CST66xx identity not confirmed (continuing)");
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool Cst66xxTouch::stop() {
|
|
return true;
|
|
}
|
|
|
|
bool Cst66xxTouch::readPoint(int16_t& x, int16_t& y) {
|
|
// CST66xx frame (cst66xx_report): write the read-point register, then read 9
|
|
// bytes. buf[2]=report type (0xFF=position/key), buf[3] low nibble = finger
|
|
// count, high nibble = key count. The first 5-byte slot (buf[4..8]) is a key
|
|
// slot when key count > 0, otherwise the first finger; further fingers, if
|
|
// any, follow at buf[index+...].
|
|
uint8_t buf[9] = {};
|
|
error_t err = i2c_controller_write(configuration.i2cController, configuration.address, REG_READ_POINT, sizeof(REG_READ_POINT), I2C_TIMEOUT);
|
|
if (err == ERROR_NONE) {
|
|
err = i2c_controller_read(configuration.i2cController, configuration.address, buf, sizeof(buf), I2C_TIMEOUT);
|
|
}
|
|
if (err != ERROR_NONE) {
|
|
return false;
|
|
}
|
|
|
|
// Acknowledge/clear the frame after every read.
|
|
i2c_controller_write(configuration.i2cController, configuration.address, CMD_ACK, sizeof(CMD_ACK), I2C_TIMEOUT);
|
|
|
|
const uint8_t reportType = buf[2];
|
|
const uint8_t fingerCount = buf[3] & 0x0F;
|
|
const uint8_t keyCount = (buf[3] & 0xF0) >> 4;
|
|
|
|
// Bezel touch-keys are reported in the first slot (buf[8]): low nibble = key
|
|
// id, high nibble = state (non-zero = pressed). The controller reports keys
|
|
// mutually exclusively with finger coordinates, so a key frame never carries
|
|
// a touch point.
|
|
if (reportType == 0xFF && keyCount > 0) {
|
|
const uint8_t keyByte = buf[8];
|
|
handleBezelKey(keyByte & 0x0F, (keyByte >> 4) != 0);
|
|
return false;
|
|
}
|
|
// No key in this frame: clear the latch so the next press fires once.
|
|
bezelKeyDown = false;
|
|
|
|
if (reportType != 0xFF || fingerCount < 1) {
|
|
return false;
|
|
}
|
|
|
|
// First finger's slot follows any key slots.
|
|
const uint8_t index = keyCount * 5;
|
|
const uint8_t event = buf[index + 8] >> 4; // 0 = up
|
|
if (event == 0) {
|
|
return false;
|
|
}
|
|
|
|
int16_t rawX = static_cast<int16_t>(buf[index + 4] | (static_cast<uint16_t>(buf[index + 7] & 0x0F) << 8));
|
|
int16_t rawY = static_cast<int16_t>(buf[index + 5] | (static_cast<uint16_t>(buf[index + 7] & 0xF0) << 4));
|
|
|
|
if (configuration.swapXy) {
|
|
std::swap(rawX, rawY);
|
|
}
|
|
if (configuration.mirrorX) {
|
|
rawX = static_cast<int16_t>(configuration.width - 1 - rawX);
|
|
}
|
|
if (configuration.mirrorY) {
|
|
rawY = static_cast<int16_t>(configuration.height - 1 - rawY);
|
|
}
|
|
|
|
x = rawX;
|
|
y = rawY;
|
|
return true;
|
|
}
|
|
|
|
// Bezel touch-key ids as reported by the CST66xx, left to right (confirmed on
|
|
// hardware). To re-map a button, change the action in the switch below — the
|
|
// mapping is also documented in NOTES.md.
|
|
static constexpr uint8_t BEZEL_KEY_HEART = 0; // left
|
|
static constexpr uint8_t BEZEL_KEY_SPEECH = 1; // centre
|
|
static constexpr uint8_t BEZEL_KEY_AIRPLANE = 2; // right
|
|
|
|
void Cst66xxTouch::handleBezelKey(uint8_t keyId, bool pressed) {
|
|
if (!pressed) {
|
|
bezelKeyDown = false;
|
|
return;
|
|
}
|
|
if (bezelKeyDown) {
|
|
return; // still held; the press edge was already handled
|
|
}
|
|
bezelKeyDown = true;
|
|
|
|
LOG_D(TAG, "bezel key %u", keyId);
|
|
|
|
// Bezel button -> navigation action. Edit these cases to customise:
|
|
switch (keyId) {
|
|
case BEZEL_KEY_HEART: // Back: stop the current app (no-op at the launcher root)
|
|
tt::app::stop();
|
|
break;
|
|
// Home (BEZEL_KEY_SPEECH) and Recents (BEZEL_KEY_AIRPLANE) are intentionally
|
|
// unbound: tt::app::start() always pushes a new instance onto the app
|
|
// stack, so repeated presses would keep growing it (Launcher/AppList
|
|
// instances never get cleaned up) and leak memory over time. The app
|
|
// stack has no API yet to collapse back to an existing instance instead
|
|
// of pushing a new one; wire these up once that exists.
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void Cst66xxTouch::readCallback(lv_indev_t* indev, lv_indev_data_t* data) {
|
|
auto* self = static_cast<Cst66xxTouch*>(lv_indev_get_user_data(indev));
|
|
|
|
int16_t x;
|
|
int16_t y;
|
|
if (self->readPoint(x, y)) {
|
|
self->lastX = x;
|
|
self->lastY = y;
|
|
data->point.x = x;
|
|
data->point.y = y;
|
|
data->state = LV_INDEV_STATE_PRESSED;
|
|
} else {
|
|
// Report the release at the last known position.
|
|
data->point.x = self->lastX;
|
|
data->point.y = self->lastY;
|
|
data->state = LV_INDEV_STATE_RELEASED;
|
|
}
|
|
}
|
|
|
|
bool Cst66xxTouch::startLvgl(lv_display_t* display) {
|
|
if (indev != nullptr) {
|
|
return true;
|
|
}
|
|
|
|
indev = lv_indev_create();
|
|
lv_indev_set_type(indev, LV_INDEV_TYPE_POINTER);
|
|
lv_indev_set_read_cb(indev, &readCallback);
|
|
lv_indev_set_display(indev, display);
|
|
lv_indev_set_user_data(indev, this);
|
|
return true;
|
|
}
|
|
|
|
bool Cst66xxTouch::stopLvgl() {
|
|
if (indev == nullptr) {
|
|
return true;
|
|
}
|
|
lv_indev_delete(indev);
|
|
indev = nullptr;
|
|
return true;
|
|
}
|