adolforeyna/tactility
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Device migrations, drivers and fixes (#571)

Browse Source 
Device migrations:

- cyd-4848S040c
- guition-jc1060p470ciwy
- guition-jc2432w328c
- guition-jc3248w535c (known issue with display and touch, Shadowtrance will look into it)
- guition-jc8048w550c
- heltec-wifi-lora-32-v3
- lilygo-tdeck-max (excluding graphics)
- lilygo-tdisplay
- lilygo-tdisplay-s3
- lilygo-tdongle-s3
- lilygo-tlora-pager

Driver migrations:

- Implemented haptic driver interface in kernel
- AXS15231b
- BQ25896
- BQ27220
- CST328
- CST6xx
- DRV2605
- JD9165
- Custom LilyGO driver for T-Lora Pager
- SSD1306
- ST7701
- ST7735
- SY6970
- TCA8418

Fixes/improvements:

- Boot app: support for multiple power devices, improved UI
- lvgl_devices and related code: fixes for mapping
- Support for arrays in dts parser
This commit is contained in:
Ken Van Hoeylandt
2026-07-18 15:01:42 +02:00
committed by GitHub
parent 3b5a401594
commit d896657bf9
290 changed files with 9113 additions and 6719 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Drivers/st7701-module/CMakeLists.txt
+11
View File
@@ -0,0 +1,11 @@
cmake_minimum_required(VERSION 3.20)
include("${CMAKE_CURRENT_LIST_DIR}/../../Buildscripts/module.cmake")
file(GLOB_RECURSE SOURCE_FILES "source/*.c*")
tactility_add_module(st7701-module
SRCS ${SOURCE_FILES}
INCLUDE_DIRS include/
REQUIRES TactilityKernel platform-esp32 esp_lcd_st7701 esp_lcd_panel_io_additions esp_lcd driver
)
Drivers/st7701-module/LICENSE-Apache-2.0.md
+195
View File
@@ -0,0 +1,195 @@
Apache License
==============
_Version 2.0, January 2004_
_&lt;<http://www.apache.org/licenses/>&gt;_
### Terms and Conditions for use, reproduction, and distribution
#### 1. Definitions
“License” shall mean the terms and conditions for use, reproduction, and
distribution as defined by Sections 1 through 9 of this document.
“Licensor” shall mean the copyright owner or entity authorized by the copyright
owner that is granting the License.
“Legal Entity” shall mean the union of the acting entity and all other entities
that control, are controlled by, or are under common control with that entity.
For the purposes of this definition, “control” means **(i)** the power, direct or
indirect, to cause the direction or management of such entity, whether by
contract or otherwise, or **(ii)** ownership of fifty percent (50%) or more of the
outstanding shares, or **(iii)** beneficial ownership of such entity.
“You” (or “Your”) shall mean an individual or Legal Entity exercising
permissions granted by this License.
“Source” form shall mean the preferred form for making modifications, including
but not limited to software source code, documentation source, and configuration
files.
“Object” form shall mean any form resulting from mechanical transformation or
translation of a Source form, including but not limited to compiled object code,
generated documentation, and conversions to other media types.
“Work” shall mean the work of authorship, whether in Source or Object form, made
available under the License, as indicated by a copyright notice that is included
in or attached to the work (an example is provided in the Appendix below).
“Derivative Works” shall mean any work, whether in Source or Object form, that
is based on (or derived from) the Work and for which the editorial revisions,
annotations, elaborations, or other modifications represent, as a whole, an
original work of authorship. For the purposes of this License, Derivative Works
shall not include works that remain separable from, or merely link (or bind by
name) to the interfaces of, the Work and Derivative Works thereof.
“Contribution” shall mean any work of authorship, including the original version
of the Work and any modifications or additions to that Work or Derivative Works
thereof, that is intentionally submitted to Licensor for inclusion in the Work
by the copyright owner or by an individual or Legal Entity authorized to submit
on behalf of the copyright owner. For the purposes of this definition,
“submitted” means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems, and
issue tracking systems that are managed by, or on behalf of, the Licensor for
the purpose of discussing and improving the Work, but excluding communication
that is conspicuously marked or otherwise designated in writing by the copyright
owner as “Not a Contribution.”
“Contributor” shall mean Licensor and any individual or Legal Entity on behalf
of whom a Contribution has been received by Licensor and subsequently
incorporated within the Work.
#### 2. Grant of Copyright License
Subject to the terms and conditions of this License, each Contributor hereby
grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
irrevocable copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the Work and such
Derivative Works in Source or Object form.
#### 3. Grant of Patent License
Subject to the terms and conditions of this License, each Contributor hereby
grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
irrevocable (except as stated in this section) patent license to make, have
made, use, offer to sell, sell, import, and otherwise transfer the Work, where
such license applies only to those patent claims licensable by such Contributor
that are necessarily infringed by their Contribution(s) alone or by combination
of their Contribution(s) with the Work to which such Contribution(s) was
submitted. If You institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work or a
Contribution incorporated within the Work constitutes direct or contributory
patent infringement, then any patent licenses granted to You under this License
for that Work shall terminate as of the date such litigation is filed.
#### 4. Redistribution
You may reproduce and distribute copies of the Work or Derivative Works thereof
in any medium, with or without modifications, and in Source or Object form,
provided that You meet the following conditions:
* **(a)** You must give any other recipients of the Work or Derivative Works a copy of
this License; and
* **(b)** You must cause any modified files to carry prominent notices stating that You
changed the files; and
* **(c)** You must retain, in the Source form of any Derivative Works that You distribute,
all copyright, patent, trademark, and attribution notices from the Source form
of the Work, excluding those notices that do not pertain to any part of the
Derivative Works; and
* **(d)** If the Work includes a “NOTICE” text file as part of its distribution, then any
Derivative Works that You distribute must include a readable copy of the
attribution notices contained within such NOTICE file, excluding those notices
that do not pertain to any part of the Derivative Works, in at least one of the
following places: within a NOTICE text file distributed as part of the
Derivative Works; within the Source form or documentation, if provided along
with the Derivative Works; or, within a display generated by the Derivative
Works, if and wherever such third-party notices normally appear. The contents of
the NOTICE file are for informational purposes only and do not modify the
License. You may add Your own attribution notices within Derivative Works that
You distribute, alongside or as an addendum to the NOTICE text from the Work,
provided that such additional attribution notices cannot be construed as
modifying the License.
You may add Your own copyright statement to Your modifications and may provide
additional or different license terms and conditions for use, reproduction, or
distribution of Your modifications, or for any such Derivative Works as a whole,
provided Your use, reproduction, and distribution of the Work otherwise complies
with the conditions stated in this License.
#### 5. Submission of Contributions
Unless You explicitly state otherwise, any Contribution intentionally submitted
for inclusion in the Work by You to the Licensor shall be under the terms and
conditions of this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify the terms of
any separate license agreement you may have executed with Licensor regarding
such Contributions.
#### 6. Trademarks
This License does not grant permission to use the trade names, trademarks,
service marks, or product names of the Licensor, except as required for
reasonable and customary use in describing the origin of the Work and
reproducing the content of the NOTICE file.
#### 7. Disclaimer of Warranty
Unless required by applicable law or agreed to in writing, Licensor provides the
Work (and each Contributor provides its Contributions) on an “AS IS” BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied,
including, without limitation, any warranties or conditions of TITLE,
NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are
solely responsible for determining the appropriateness of using or
redistributing the Work and assume any risks associated with Your exercise of
permissions under this License.
#### 8. Limitation of Liability
In no event and under no legal theory, whether in tort (including negligence),
contract, or otherwise, unless required by applicable law (such as deliberate
and grossly negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special, incidental,
or consequential damages of any character arising as a result of this License or
out of the use or inability to use the Work (including but not limited to
damages for loss of goodwill, work stoppage, computer failure or malfunction, or
any and all other commercial damages or losses), even if such Contributor has
been advised of the possibility of such damages.
#### 9. Accepting Warranty or Additional Liability
While redistributing the Work or Derivative Works thereof, You may choose to
offer, and charge a fee for, acceptance of support, warranty, indemnity, or
other liability obligations and/or rights consistent with this License. However,
in accepting such obligations, You may act only on Your own behalf and on Your
sole responsibility, not on behalf of any other Contributor, and only if You
agree to indemnify, defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason of your
accepting any such warranty or additional liability.
_END OF TERMS AND CONDITIONS_
### APPENDIX: How to apply the Apache License to your work
To apply the Apache License to your work, attach the following boilerplate
notice, with the fields enclosed by brackets `[]` replaced with your own
identifying information. (Don't include the brackets!) The text should be
enclosed in the appropriate comment syntax for the file format. We also
recommend that a file or class name and description of purpose be included on
the same “printed page” as the copyright notice for easier identification within
third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Drivers/st7701-module/bindings/sitronix,st7701.yaml
+263
View File
@@ -0,0 +1,263 @@
description: >
Sitronix ST7701 display panel, driven over ESP-IDF's esp_lcd_st7701 component. Like
espressif,esp32-rgb-display, pixel data goes out over the RGB (parallel timing-driven)
interface, but the panel also has its own command interface: a bit-banged 3-wire SPI bus
(CS/SCL/SDA over plain GPIOs) used to push the vendor bring-up sequence and, optionally,
runtime commands (mirror, display on/off).
compatible: "sitronix,st7701"
properties:
horizontal-resolution:
type: int
required: true
description: Horizontal resolution in pixels
vertical-resolution:
type: int
required: true
description: Vertical resolution in pixels
pixel-clock-hz:
type: int
required: true
description: Pixel clock frequency in Hz
hsync-pulse-width:
type: int
required: true
description: Horizontal sync width, in PCLK periods
hsync-back-porch:
type: int
required: true
description: Number of PCLK periods between hsync and the start of line active data
hsync-front-porch:
type: int
required: true
description: Number of PCLK periods between the end of active data and the next hsync
vsync-pulse-width:
type: int
required: true
description: Vertical sync width, in lines
vsync-back-porch:
type: int
required: true
description: Number of invalid lines between vsync and the start of the frame
vsync-front-porch:
type: int
required: true
description: Number of invalid lines between the end of the frame and the next vsync
hsync-idle-low:
type: boolean
default: false
description: The hsync signal is low in the idle state
vsync-idle-low:
type: boolean
default: false
description: The vsync signal is low in the idle state
de-idle-high:
type: boolean
default: false
description: The DE signal is high in the idle state
pclk-active-neg:
type: boolean
default: false
description: Whether display data is clocked out on the falling edge of PCLK
pclk-idle-high:
type: boolean
default: false
description: The PCLK signal stays high in the idle phase
data-width:
type: int
default: 16
description: Number of parallel data lines wired (8 or 16)
bits-per-pixel:
type: int
default: 16
description: Color depth in bits per pixel (16, 18 or 24 - the ST7701 has no "match data-width" default)
num-fbs:
type: int
default: 1
description: Number of screen-sized frame buffers to allocate (0 or 1 = single-buffered)
bounce-buffer-size-px:
type: int
default: 0
description: Non-zero enables the DRAM bounce-buffer DMA path, sized in pixels
sram-trans-align:
type: int
default: 8
description: Alignment of buffers allocated in internal SRAM
psram-trans-align:
type: int
default: 64
description: Alignment of buffers allocated in PSRAM
pin-hsync:
type: phandles
default: GPIO_PIN_SPEC_NONE
description: HSYNC GPIO pin, optional for panels that only need DE (data-enable) sync
pin-vsync:
type: phandles
default: GPIO_PIN_SPEC_NONE
description: VSYNC GPIO pin, optional for panels that only need DE (data-enable) sync
pin-de:
type: phandles
default: GPIO_PIN_SPEC_NONE
description: Data-enable GPIO pin, optional
pin-pclk:
type: phandles
required: true
description: Pixel-clock GPIO pin
pin-disp:
type: phandles
default: GPIO_PIN_SPEC_NONE
description: Optional display-enable control GPIO pin
pin-data0:
type: phandles
default: GPIO_PIN_SPEC_NONE
description: Data bus bit 0 GPIO pin
pin-data1:
type: phandles
default: GPIO_PIN_SPEC_NONE
description: Data bus bit 1 GPIO pin
pin-data2:
type: phandles
default: GPIO_PIN_SPEC_NONE
description: Data bus bit 2 GPIO pin
pin-data3:
type: phandles
default: GPIO_PIN_SPEC_NONE
description: Data bus bit 3 GPIO pin
pin-data4:
type: phandles
default: GPIO_PIN_SPEC_NONE
description: Data bus bit 4 GPIO pin
pin-data5:
type: phandles
default: GPIO_PIN_SPEC_NONE
description: Data bus bit 5 GPIO pin
pin-data6:
type: phandles
default: GPIO_PIN_SPEC_NONE
description: Data bus bit 6 GPIO pin
pin-data7:
type: phandles
default: GPIO_PIN_SPEC_NONE
description: Data bus bit 7 GPIO pin
pin-data8:
type: phandles
default: GPIO_PIN_SPEC_NONE
description: Data bus bit 8 GPIO pin
pin-data9:
type: phandles
default: GPIO_PIN_SPEC_NONE
description: Data bus bit 9 GPIO pin
pin-data10:
type: phandles
default: GPIO_PIN_SPEC_NONE
description: Data bus bit 10 GPIO pin
pin-data11:
type: phandles
default: GPIO_PIN_SPEC_NONE
description: Data bus bit 11 GPIO pin
pin-data12:
type: phandles
default: GPIO_PIN_SPEC_NONE
description: Data bus bit 12 GPIO pin
pin-data13:
type: phandles
default: GPIO_PIN_SPEC_NONE
description: Data bus bit 13 GPIO pin
pin-data14:
type: phandles
default: GPIO_PIN_SPEC_NONE
description: Data bus bit 14 GPIO pin
pin-data15:
type: phandles
default: GPIO_PIN_SPEC_NONE
description: Data bus bit 15 GPIO pin
disp-active-low:
type: boolean
default: false
description: A low level on the display-enable control signal turns the screen on
refresh-on-demand:
type: boolean
default: false
description: Only refresh the frame buffer on explicit draw_bitmap calls
fb-in-psram:
type: boolean
default: true
description: Allocate the frame buffer from PSRAM, preferentially
double-fb:
type: boolean
default: false
description: Allocate two screen-sized frame buffers (equivalent to num-fbs = 2)
no-fb:
type: boolean
default: false
description: Don't allocate a frame buffer; bounce buffer must be filled manually
bb-invalidate-cache:
type: boolean
default: false
description: Invalidate cache on bounce-buffer reads (can be dangerous with multi-core writers)
swap-xy:
type: boolean
default: false
description: Swap the X and Y axes
mirror-x:
type: boolean
default: false
description: Mirror the X axis
mirror-y:
type: boolean
default: false
description: Mirror the Y axis
invert-color:
type: boolean
default: false
description: Invert the panel's color output
pin-cs:
type: phandles
required: true
description: Chip-select GPIO pin for the bit-banged 3-wire command bus
pin-scl:
type: phandles
required: true
description: Clock GPIO pin for the bit-banged 3-wire command bus
pin-sda:
type: phandles
required: true
description: Data GPIO pin for the bit-banged 3-wire command bus (write-only, no MISO)
scl-active-edge:
type: boolean
default: false
description: Sample data on the falling edge of SCL instead of the rising edge
pin-reset:
type: phandles
default: GPIO_PIN_SPEC_NONE
description: Optional hardware reset pin for the panel. Falls back to a software reset
(sent over the 3-wire bus) if not set.
reset-active-high:
type: boolean
default: false
description: Whether the reset pin is active high
mirror-by-cmd:
type: boolean
default: false
description: Implement mirror() by sending an LCD command instead of flipping the RGB
peripheral's scan direction in software
auto-del-panel-io:
type: boolean
default: false
description: Release the 3-wire command bus (and its pins) right after bring-up. Only
useful when those pins are physically shared with the RGB data/sync pins; leave false
if the 3-wire bus has its own dedicated pins, since runtime commands (mirror-by-cmd,
disp-on-off without a dedicated pin-disp) need the bus to stay alive.
init-sequence:
type: array
element-type: uint8_t
description: >
Custom vendor bring-up sequence, flattened into bytes as a run of
[cmd, data-length, delay-ms, data-length bytes of data...] entries, e.g.
`init-sequence = [0xFF 5 0 0x77 0x01 0x00 0x00 0x10 0x11 0 120 0x29 0 0];`.
Omit to use the ST7701 component's own built-in default sequence.
backlight:
type: phandle
default: "NULL"
description: Optional reference to this display's backlight device
Drivers/st7701-module/devicetree.yaml
+3
View File
@@ -0,0 +1,3 @@
dependencies:
- TactilityKernel
bindings: bindings
Drivers/st7701-module/include/bindings/st7701.h
+10
View File
@@ -0,0 +1,10 @@
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include <tactility/bindings/bindings.h>
#include <drivers/st7701.h>
// The devicetree compiler derives the expected config typedef name from the compatible
// string's suffix (e.g. "sitronix,st7701" -> st7701_config_dt), not from the node name or
// driver name, so the tag here must match that exactly.
DEFINE_DEVICETREE(st7701, struct St7701Config)
Drivers/st7701-module/include/drivers/st7701.h
+111
View File
@@ -0,0 +1,111 @@
// SPDX-License-Identifier: Apache-2.0
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
#include <stdint.h>
#include <stdbool.h>
#include <tactility/device.h>
#include <tactility/drivers/gpio.h>
struct St7701Config {
uint16_t horizontal_resolution;
uint16_t vertical_resolution;
uint32_t pixel_clock_hz;
uint32_t hsync_pulse_width;
uint32_t hsync_back_porch;
uint32_t hsync_front_porch;
uint32_t vsync_pulse_width;
uint32_t vsync_back_porch;
uint32_t vsync_front_porch;
bool hsync_idle_low;
bool vsync_idle_low;
bool de_idle_high;
bool pclk_active_neg;
bool pclk_idle_high;
// Number of parallel data lines actually wired (8 or 16). Only the first data_width
// pin-dataN fields below are used; the rest are ignored.
uint8_t data_width;
// Color depth in bpp (16, 18 or 24). Passed to both the RGB timing config and the ST7701
// vendor config, which uses it to pick its MADCTL/COLMOD bring-up values.
uint8_t bits_per_pixel;
// Number of screen-sized frame buffers the driver allocates (0 or 1 = single-buffered).
uint8_t num_fbs;
// Non-zero enables the DRAM bounce-buffer DMA path, sized in pixels.
uint32_t bounce_buffer_size_px;
uint32_t sram_trans_align;
uint32_t psram_trans_align;
struct GpioPinSpec pin_hsync;
struct GpioPinSpec pin_vsync;
struct GpioPinSpec pin_de;
struct GpioPinSpec pin_pclk;
// Optional display-enable control pin, GPIO_PIN_SPEC_NONE if unused.
struct GpioPinSpec pin_disp;
struct GpioPinSpec pin_data0;
struct GpioPinSpec pin_data1;
struct GpioPinSpec pin_data2;
struct GpioPinSpec pin_data3;
struct GpioPinSpec pin_data4;
struct GpioPinSpec pin_data5;
struct GpioPinSpec pin_data6;
struct GpioPinSpec pin_data7;
struct GpioPinSpec pin_data8;
struct GpioPinSpec pin_data9;
struct GpioPinSpec pin_data10;
struct GpioPinSpec pin_data11;
struct GpioPinSpec pin_data12;
struct GpioPinSpec pin_data13;
struct GpioPinSpec pin_data14;
struct GpioPinSpec pin_data15;
bool disp_active_low;
bool refresh_on_demand;
bool fb_in_psram;
bool double_fb;
bool no_fb;
bool bb_invalidate_cache;
bool swap_xy;
bool mirror_x;
bool mirror_y;
bool invert_color;
// Bit-banged 3-wire command bus (CS/SCL/SDA over plain GPIOs) used to push the vendor
// bring-up sequence and, depending on flags below, runtime commands. Separate from the
// RGB pixel bus above - the ST7701 has no MISO line in 3-wire mode.
struct GpioPinSpec pin_cs;
struct GpioPinSpec pin_scl;
struct GpioPinSpec pin_sda;
bool scl_active_edge;
// Optional hardware reset pin for the panel. GPIO_PIN_SPEC_NONE falls back to a software
// reset sent over the 3-wire bus (see esp_lcd_st7701's panel_st7701_reset()).
struct GpioPinSpec pin_reset;
bool reset_active_high;
// See the 'mirror-by-cmd' and 'auto-del-panel-io' binding properties.
bool mirror_by_cmd;
bool auto_del_panel_io;
// Custom vendor init sequence, flattened as bytes: a run of
// [cmd, data_len, delay_ms, data_len bytes of data...] entries. NULL/0 falls back to the
// ST7701 component's own built-in default sequence (see vendor_specific_init_default in
// esp_lcd_st7701_rgb.c) - not guaranteed to match any particular panel's actual bring-up
// requirements, so most boards should supply their own via this property.
const uint8_t* init_sequence;
uint32_t init_sequence_length;
// Optional reference to this display's backlight device, NULL if none.
struct Device* backlight;
};
#ifdef __cplusplus
}
#endif
Drivers/st7701-module/include/st7701_module.h
+14
View File
@@ -0,0 +1,14 @@
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include <tactility/module.h>
#ifdef __cplusplus
extern "C" {
#endif
extern struct Module st7701_module;
#ifdef __cplusplus
}
#endif
Drivers/st7701-module/source/module.cpp
+32
View File
@@ -0,0 +1,32 @@
// SPDX-License-Identifier: Apache-2.0
#include <tactility/check.h>
#include <tactility/driver.h>
#include <tactility/module.h>
extern "C" {
extern Driver st7701_driver;
static error_t start() {
/* We crash when construct fails, because if a single driver fails to construct,
* there is no guarantee that the previously constructed drivers can be destroyed */
check(driver_construct_add(&st7701_driver) == ERROR_NONE);
return ERROR_NONE;
}
static error_t stop() {
/* We crash when destruct fails, because if a single driver fails to destruct,
* there is no guarantee that the previously destroyed drivers can be recovered */
check(driver_remove_destruct(&st7701_driver) == ERROR_NONE);
return ERROR_NONE;
}
Module st7701_module = {
.name = "st7701",
.start = start,
.stop = stop,
.symbols = nullptr,
.internal = nullptr
};
} // extern "C"
Drivers/st7701-module/source/st7701.cpp
+543
View File
@@ -0,0 +1,543 @@
// SPDX-License-Identifier: Apache-2.0
#include <soc/soc_caps.h>
#if SOC_LCD_RGB_SUPPORTED
#include <drivers/st7701.h>
#include <st7701_module.h>
#include <tactility/device.h>
#include <tactility/driver.h>
#include <tactility/drivers/display.h>
#include <tactility/error.h>
#include <tactility/log.h>
#include <esp_err.h>
#include <esp_lcd_panel_io.h>
#include <esp_lcd_panel_io_additions.h>
#include <esp_lcd_panel_ops.h>
#include <esp_lcd_panel_rgb.h>
#include <esp_lcd_st7701.h>
#include <freertos/FreeRTOS.h>
#include <freertos/semphr.h>
#include <cstdlib>
#define TAG "St7701"
#define GET_CONFIG(device) (static_cast<const St7701Config*>((device)->config))
// Generic lvgl-module display glue (Modules/lvgl-module/source/lvgl_display.c) only ever asks
// for frame buffer index 0 and 1, so caching more than that would be dead weight.
constexpr size_t MAX_CACHED_FRAME_BUFFERS = 2;
struct St7701Internal {
esp_lcd_panel_io_handle_t io_handle;
esp_lcd_panel_handle_t panel_handle;
void* frame_buffers[MAX_CACHED_FRAME_BUFFERS];
uint8_t frame_buffer_count;
// Size of each buffer in frame_buffers, in bytes - used to range-check whether a given
// draw_bitmap() color_data pointer is actually one of them (see draw_bitmap() below).
size_t frame_buffer_size_bytes;
// Signaled by on_frame_buf_complete once per real DMA scan-out of a whole frame. Only
// waited on in draw_bitmap() when color_data is one of frame_buffers - see the comment there.
SemaphoreHandle_t frame_complete_semaphore;
// Heap-allocated only when the devicetree supplies a custom init_sequence (see
// parse_init_sequence()) - nullptr otherwise, since the vendor's built-in default sequence
// needs no parsing. Its .data pointers alias directly into the devicetree's static const
// byte buffer, so only this struct array itself needs freeing in stop().
st7701_lcd_init_cmd_t* parsed_init_cmds;
};
// esp_lcd_rgb_panel's draw_bitmap() has a zero-copy path when color_data is one of the panel's
// own frame buffers (as returned by esp_lcd_rgb_panel_get_frame_buffer()): it just repoints which
// buffer is scanned out and returns almost instantly - well before the RGB peripheral's DMA has
// actually finished scanning out the *previous* buffer, let alone started on this one. Callers in
// full/direct LVGL render mode render straight into these real frame buffers, so if draw_bitmap()
// returned that quickly, LVGL would be free to start overwriting the *other* buffer - which may
// still be mid-scanout - producing visible tearing/flashing. on_frame_buf_complete fires once per
// actual whole-frame DMA completion (continuously, at the panel's refresh rate, independent of
// draw_bitmap calls), so waiting for the next occurrence after each draw_bitmap() genuinely
// blocks until it's safe to start writing into the frame buffers again.
static bool IRAM_ATTR on_frame_buf_complete(esp_lcd_panel_handle_t, const esp_lcd_rgb_panel_event_data_t*, void* user_ctx) {
auto* internal = static_cast<St7701Internal*>(user_ctx);
BaseType_t high_task_woken = pdFALSE;
xSemaphoreGiveFromISR(internal->frame_complete_semaphore, &high_task_woken);
return high_task_woken == pdTRUE;
}
static int pin_or_unused(const GpioPinSpec& pin) {
return pin.gpio_controller == nullptr ? -1 : static_cast<int>(pin.pin);
}
// Unpacks the devicetree's flat [cmd, data_len, delay_ms, data_len bytes...] encoding (produced
// by the devicetree compiler's "array" property type - see init-sequence in
// bindings/sitronix,st7701.yaml) into a heap-allocated st7701_lcd_init_cmd_t array. Each entry's
// .data points directly into `bytes`, which is the devicetree's static const buffer and outlives
// the device, so no per-entry copy is needed.
static bool parse_init_sequence(const uint8_t* bytes, uint32_t length, st7701_lcd_init_cmd_t** out_cmds, uint16_t* out_count) {
uint32_t count = 0;
for (uint32_t offset = 0; offset < length; count++) {
if (offset + 3 > length) {
LOG_E(TAG, "init-sequence truncated: entry header runs past the end of the array");
return false;
}
offset += 3 + bytes[offset + 1];
if (offset > length) {
LOG_E(TAG, "init-sequence truncated: entry data runs past the end of the array");
return false;
}
}
auto* cmds = static_cast<st7701_lcd_init_cmd_t*>(malloc(count * sizeof(st7701_lcd_init_cmd_t)));
if (cmds == nullptr) {
return false;
}
uint32_t offset = 0;
for (uint32_t i = 0; i < count; i++) {
uint8_t data_len = bytes[offset + 1];
cmds[i] = {
.cmd = bytes[offset],
.data = data_len > 0 ? &bytes[offset + 3] : nullptr,
.data_bytes = data_len,
.delay_ms = bytes[offset + 2],
};
offset += 3 + data_len;
}
*out_cmds = cmds;
*out_count = (uint16_t)count;
return true;
}
// region Driver lifecycle
static error_t start(Device* device) {
const auto* config = GET_CONFIG(device);
auto* internal = static_cast<St7701Internal*>(malloc(sizeof(St7701Internal)));
if (internal == nullptr) {
return ERROR_OUT_OF_MEMORY;
}
internal->parsed_init_cmds = nullptr;
const st7701_lcd_init_cmd_t* init_cmds = nullptr;
uint16_t init_cmds_size = 0;
if (config->init_sequence != nullptr && config->init_sequence_length > 0) {
if (!parse_init_sequence(config->init_sequence, config->init_sequence_length, &internal->parsed_init_cmds, &init_cmds_size)) {
LOG_E(TAG, "Failed to parse init-sequence property");
free(internal);
return ERROR_INVALID_ARGUMENT;
}
init_cmds = internal->parsed_init_cmds;
}
spi_line_config_t line_config = {
.cs_io_type = IO_TYPE_GPIO,
.cs_gpio_num = pin_or_unused(config->pin_cs),
.scl_io_type = IO_TYPE_GPIO,
.scl_gpio_num = pin_or_unused(config->pin_scl),
.sda_io_type = IO_TYPE_GPIO,
.sda_gpio_num = pin_or_unused(config->pin_sda),
.io_expander = nullptr,
};
// scl_active_edge is a runtime bool, not a compile-time constant, so it can't be passed
// through the macro's brace-init `.spi_mode = scl_active_edge ? 1 : 0` directly - that trips
// -Werror=narrowing on the bitfield (only literal 0/1 args avoid it). Assign it afterward
// instead, as a plain (non-narrowing) assignment.
esp_lcd_panel_io_3wire_spi_config_t io_config = ST7701_PANEL_IO_3WIRE_SPI_CONFIG(line_config, 0);
io_config.spi_mode = config->scl_active_edge ? 1 : 0;
esp_err_t ret = esp_lcd_new_panel_io_3wire_spi(&io_config, &internal->io_handle);
if (ret != ESP_OK) {
LOG_E(TAG, "Failed to create panel IO: %s", esp_err_to_name(ret));
free(internal->parsed_init_cmds);
free(internal);
return ERROR_RESOURCE;
}
esp_lcd_rgb_panel_config_t rgb_config = {
.clk_src = LCD_CLK_SRC_DEFAULT,
.timings = {
.pclk_hz = config->pixel_clock_hz,
.h_res = config->horizontal_resolution,
.v_res = config->vertical_resolution,
.hsync_pulse_width = config->hsync_pulse_width,
.hsync_back_porch = config->hsync_back_porch,
.hsync_front_porch = config->hsync_front_porch,
.vsync_pulse_width = config->vsync_pulse_width,
.vsync_back_porch = config->vsync_back_porch,
.vsync_front_porch = config->vsync_front_porch,
.flags = {
.hsync_idle_low = config->hsync_idle_low,
.vsync_idle_low = config->vsync_idle_low,
.de_idle_high = config->de_idle_high,
.pclk_active_neg = config->pclk_active_neg,
.pclk_idle_high = config->pclk_idle_high,
}
},
.data_width = config->data_width,
.bits_per_pixel = config->bits_per_pixel,
.num_fbs = config->num_fbs,
.bounce_buffer_size_px = config->bounce_buffer_size_px,
.sram_trans_align = config->sram_trans_align,
.psram_trans_align = config->psram_trans_align,
.hsync_gpio_num = pin_or_unused(config->pin_hsync),
.vsync_gpio_num = pin_or_unused(config->pin_vsync),
.de_gpio_num = pin_or_unused(config->pin_de),
.pclk_gpio_num = pin_or_unused(config->pin_pclk),
.disp_gpio_num = pin_or_unused(config->pin_disp),
.data_gpio_nums = {
pin_or_unused(config->pin_data0),
pin_or_unused(config->pin_data1),
pin_or_unused(config->pin_data2),
pin_or_unused(config->pin_data3),
pin_or_unused(config->pin_data4),
pin_or_unused(config->pin_data5),
pin_or_unused(config->pin_data6),
pin_or_unused(config->pin_data7),
pin_or_unused(config->pin_data8),
pin_or_unused(config->pin_data9),
pin_or_unused(config->pin_data10),
pin_or_unused(config->pin_data11),
pin_or_unused(config->pin_data12),
pin_or_unused(config->pin_data13),
pin_or_unused(config->pin_data14),
pin_or_unused(config->pin_data15),
},
.flags = {
.disp_active_low = config->disp_active_low,
.refresh_on_demand = config->refresh_on_demand,
.fb_in_psram = config->fb_in_psram,
.double_fb = config->double_fb,
.no_fb = config->no_fb,
.bb_invalidate_cache = config->bb_invalidate_cache,
}
};
// This Config struct only exposes 16 named data pins, so on chips whose RGB peripheral has
// more data lines than that, the tail of the array must be explicitly marked unused rather
// than left as the aggregate-init default of 0 (which would look like "GPIO0 is wired here").
for (size_t i = 16; i < sizeof(rgb_config.data_gpio_nums) / sizeof(rgb_config.data_gpio_nums[0]); i++) {
rgb_config.data_gpio_nums[i] = -1;
}
st7701_vendor_config_t vendor_config = {
.init_cmds = init_cmds,
.init_cmds_size = init_cmds_size,
.rgb_config = &rgb_config,
.flags = {
.use_mipi_interface = 0,
.mirror_by_cmd = config->mirror_by_cmd,
.auto_del_panel_io = config->auto_del_panel_io,
},
};
esp_lcd_panel_dev_config_t panel_config = {
.reset_gpio_num = pin_or_unused(config->pin_reset),
.rgb_ele_order = LCD_RGB_ELEMENT_ORDER_RGB,
.data_endian = LCD_RGB_DATA_ENDIAN_LITTLE,
.bits_per_pixel = config->bits_per_pixel,
.flags = { .reset_active_high = config->reset_active_high },
.vendor_config = &vendor_config,
};
ret = esp_lcd_new_panel_st7701(internal->io_handle, &panel_config, &internal->panel_handle);
if (ret != ESP_OK) {
LOG_E(TAG, "Failed to create panel: %s", esp_err_to_name(ret));
esp_lcd_panel_io_del(internal->io_handle);
free(internal->parsed_init_cmds);
free(internal);
return ERROR_RESOURCE;
}
// Bring-up sequence: reset() pulses (or software-resets) the panel and init() pushes
// init_cmds over the 3-wire bus before bringing up the underlying RGB peripheral. Every
// failure path below must clean up fully: unlike stop_device, this is never retried by the
// kernel if start_device fails (see device_start() in TactilityKernel), so a partial failure
// here would leak.
bool ok =
esp_lcd_panel_reset(internal->panel_handle) == ESP_OK &&
esp_lcd_panel_init(internal->panel_handle) == ESP_OK &&
esp_lcd_panel_swap_xy(internal->panel_handle, config->swap_xy) == ESP_OK &&
esp_lcd_panel_mirror(internal->panel_handle, config->mirror_x, config->mirror_y) == ESP_OK &&
esp_lcd_panel_invert_color(internal->panel_handle, config->invert_color) == ESP_OK &&
esp_lcd_panel_disp_on_off(internal->panel_handle, true) == ESP_OK;
if (!ok) {
LOG_E(TAG, "Failed to bring up panel");
esp_lcd_panel_del(internal->panel_handle);
if (!config->auto_del_panel_io) {
esp_lcd_panel_io_del(internal->io_handle);
}
free(internal->parsed_init_cmds);
free(internal);
return ERROR_RESOURCE;
}
internal->frame_buffer_count = 0;
internal->frame_buffer_size_bytes = (size_t)config->horizontal_resolution * config->vertical_resolution *
((config->bits_per_pixel + 7) / 8);
if (config->num_fbs > 0) {
// esp_lcd_rgb_panel_get_frame_buffer() is variadic: the number of out-pointer arguments
// passed must match fb_num exactly, so this can't be a loop.
size_t fb_num = config->num_fbs < MAX_CACHED_FRAME_BUFFERS ? config->num_fbs : MAX_CACHED_FRAME_BUFFERS;
switch (fb_num) {
case 1:
ret = esp_lcd_rgb_panel_get_frame_buffer(internal->panel_handle, 1, &internal->frame_buffers[0]);
break;
case 2:
ret = esp_lcd_rgb_panel_get_frame_buffer(internal->panel_handle, 2, &internal->frame_buffers[0], &internal->frame_buffers[1]);
break;
default:
ret = ESP_OK;
break;
}
if (ret != ESP_OK) {
LOG_E(TAG, "Failed to get frame buffer(s): %s", esp_err_to_name(ret));
esp_lcd_panel_del(internal->panel_handle);
if (!config->auto_del_panel_io) {
esp_lcd_panel_io_del(internal->io_handle);
}
free(internal->parsed_init_cmds);
free(internal);
return ERROR_RESOURCE;
}
internal->frame_buffer_count = (uint8_t)fb_num;
}
internal->frame_complete_semaphore = xSemaphoreCreateBinary();
if (internal->frame_complete_semaphore == nullptr) {
esp_lcd_panel_del(internal->panel_handle);
if (!config->auto_del_panel_io) {
esp_lcd_panel_io_del(internal->io_handle);
}
free(internal->parsed_init_cmds);
free(internal);
return ERROR_OUT_OF_MEMORY;
}
esp_lcd_rgb_panel_event_callbacks_t callbacks = {};
callbacks.on_frame_buf_complete = on_frame_buf_complete;
if (esp_lcd_rgb_panel_register_event_callbacks(internal->panel_handle, &callbacks, internal) != ESP_OK) {
LOG_E(TAG, "Failed to register panel event callbacks");
vSemaphoreDelete(internal->frame_complete_semaphore);
esp_lcd_panel_del(internal->panel_handle);
if (!config->auto_del_panel_io) {
esp_lcd_panel_io_del(internal->io_handle);
}
free(internal->parsed_init_cmds);
free(internal);
return ERROR_RESOURCE;
}
device_set_driver_data(device, internal);
return ERROR_NONE;
}
static error_t stop(Device* device) {
const auto* config = GET_CONFIG(device);
auto* internal = static_cast<St7701Internal*>(device_get_driver_data(device));
if (internal->panel_handle != nullptr) {
if (esp_lcd_panel_del(internal->panel_handle) != ESP_OK) {
LOG_E(TAG, "Failed to delete panel");
return ERROR_RESOURCE;
}
internal->panel_handle = nullptr;
}
// If auto_del_panel_io was set, esp_lcd_new_panel_st7701() already deleted the IO handle
// itself right after bring-up (to free pins shared with the RGB bus) - deleting it again
// here would double-free.
if (!config->auto_del_panel_io && internal->io_handle != nullptr) {
if (esp_lcd_panel_io_del(internal->io_handle) != ESP_OK) {
LOG_E(TAG, "Failed to delete panel IO");
return ERROR_RESOURCE;
}
internal->io_handle = nullptr;
}
vSemaphoreDelete(internal->frame_complete_semaphore);
free(internal->parsed_init_cmds);
free(internal);
device_set_driver_data(device, nullptr);
return ERROR_NONE;
}
// endregion
// region DisplayApi
static error_t st7701_reset(Device* device) {
auto* internal = static_cast<St7701Internal*>(device_get_driver_data(device));
return esp_lcd_panel_reset(internal->panel_handle) == ESP_OK ? ERROR_NONE : ERROR_RESOURCE;
}
static error_t st7701_init(Device* device) {
auto* internal = static_cast<St7701Internal*>(device_get_driver_data(device));
return esp_lcd_panel_init(internal->panel_handle) == ESP_OK ? ERROR_NONE : ERROR_RESOURCE;
}
// Only block for scan-out completion when color_data is actually one of the panel's own frame
// buffers (see on_frame_buf_complete's comment above for why that matters) - i.e. this specific
// call is a zero-copy flip, not a plain CPU copy into the panel's buffer from a caller-owned one
// (e.g. LVGL bound in owned-buffer mode), which has no reuse race to guard against and shouldn't
// pay the up-to-one-frame latency cost for every partial update.
static bool st7701_color_data_is_frame_buffer(const St7701Internal* internal, const void* color_data) {
const auto* ptr = static_cast<const uint8_t*>(color_data);
for (uint8_t i = 0; i < internal->frame_buffer_count; i++) {
const auto* base = static_cast<const uint8_t*>(internal->frame_buffers[i]);
if (ptr >= base && ptr < base + internal->frame_buffer_size_bytes) {
return true;
}
}
return false;
}
static error_t st7701_draw_bitmap(Device* device, int32_t x_start, int32_t y_start, int32_t x_end, int32_t y_end, const void* color_data) {
auto* internal = static_cast<St7701Internal*>(device_get_driver_data(device));
bool wait_for_scanout = st7701_color_data_is_frame_buffer(internal, color_data);
if (wait_for_scanout) {
xSemaphoreTake(internal->frame_complete_semaphore, 0); // clear any already-pending signal
}
if (esp_lcd_panel_draw_bitmap(internal->panel_handle, x_start, y_start, x_end, y_end, color_data) != ESP_OK) {
return ERROR_RESOURCE;
}
if (wait_for_scanout) {
xSemaphoreTake(internal->frame_complete_semaphore, portMAX_DELAY);
}
return ERROR_NONE;
}
static error_t st7701_mirror(Device* device, bool x_axis, bool y_axis) {
auto* internal = static_cast<St7701Internal*>(device_get_driver_data(device));
return esp_lcd_panel_mirror(internal->panel_handle, x_axis, y_axis) == ESP_OK ? ERROR_NONE : ERROR_RESOURCE;
}
static error_t st7701_swap_xy(Device* device, bool swap_axes) {
auto* internal = static_cast<St7701Internal*>(device_get_driver_data(device));
return esp_lcd_panel_swap_xy(internal->panel_handle, swap_axes) == ESP_OK ? ERROR_NONE : ERROR_RESOURCE;
}
static bool st7701_get_swap_xy(Device* device) {
return GET_CONFIG(device)->swap_xy;
}
static bool st7701_get_mirror_x(Device* device) {
return GET_CONFIG(device)->mirror_x;
}
static bool st7701_get_mirror_y(Device* device) {
return GET_CONFIG(device)->mirror_y;
}
// set_gap is not exposed: like plain RGB panels, the ST7701's RGB interface is a raw scan-out
// framebuffer with no addressable-window concept, so there's no gap to set.
static error_t st7701_invert_color(Device* device, bool invert_color_data) {
auto* internal = static_cast<St7701Internal*>(device_get_driver_data(device));
return esp_lcd_panel_invert_color(internal->panel_handle, invert_color_data) == ESP_OK ? ERROR_NONE : ERROR_RESOURCE;
}
static error_t st7701_disp_on_off(Device* device, bool on_off) {
auto* internal = static_cast<St7701Internal*>(device_get_driver_data(device));
return esp_lcd_panel_disp_on_off(internal->panel_handle, on_off) == ESP_OK ? ERROR_NONE : ERROR_RESOURCE;
}
// disp_sleep is not exposed: esp_lcd_st7701's RGB variant has no sleep-mode entry point of its
// own (only init/del/reset/mirror/disp_on_off are overridden - see esp_lcd_st7701_rgb.c).
static enum DisplayColorFormat st7701_get_color_format(Device*) {
return DISPLAY_COLOR_FORMAT_RGB565;
}
static uint16_t st7701_get_resolution_x(Device* device) {
return GET_CONFIG(device)->horizontal_resolution;
}
static uint16_t st7701_get_resolution_y(Device* device) {
return GET_CONFIG(device)->vertical_resolution;
}
static void st7701_get_frame_buffer(Device* device, uint8_t index, void** out_buffer) {
auto* internal = static_cast<St7701Internal*>(device_get_driver_data(device));
*out_buffer = index < internal->frame_buffer_count ? internal->frame_buffers[index] : nullptr;
}
static uint8_t st7701_get_frame_buffer_count(Device* device) {
auto* internal = static_cast<St7701Internal*>(device_get_driver_data(device));
return internal->frame_buffer_count;
}
static error_t st7701_get_backlight(Device* device, Device** backlight) {
auto* configured_backlight = GET_CONFIG(device)->backlight;
if (configured_backlight == nullptr) {
return ERROR_NOT_SUPPORTED;
}
*backlight = configured_backlight;
return ERROR_NONE;
}
constexpr uint32_t ST7701_CAPABILITIES = DISPLAY_CAPABILITY_CAP_MIRROR | DISPLAY_CAPABILITY_CAP_SWAP_XY |
DISPLAY_CAPABILITY_INVERT_COLOR | DISPLAY_CAPABILITY_ON_OFF | DISPLAY_CAPABILITY_BACKLIGHT;
// Same reasoning as rgb_display's has_capability(): mirror()/swap_xy()'s rotate_mask is only
// applied when draw_bitmap()'s color_data is copied into the frame buffer by CPU. When
// frame_buffer_count > 0, LVGL is bound directly onto the panel's own frame buffers, so that copy
// - and with it the rotation - never happens for CAP_SWAP_XY. CAP_MIRROR is unaffected here
// because mirror_by_cmd (if set) still takes effect regardless of the frame-buffer-bound path.
static bool st7701_has_capability(Device* device, uint32_t capability) {
auto* internal = static_cast<St7701Internal*>(device_get_driver_data(device));
uint32_t capabilities = ST7701_CAPABILITIES;
if (internal->frame_buffer_count > 0 && !GET_CONFIG(device)->mirror_by_cmd) {
capabilities &= ~DISPLAY_CAPABILITY_CAP_MIRROR;
}
if (internal->frame_buffer_count > 0) {
capabilities &= ~DISPLAY_CAPABILITY_CAP_SWAP_XY;
}
return (capabilities & capability) == capability;
}
// endregion
static const DisplayApi st7701_display_api = {
.capabilities = ST7701_CAPABILITIES,
.reset = st7701_reset,
.init = st7701_init,
.draw_bitmap = st7701_draw_bitmap,
.mirror = st7701_mirror,
.swap_xy = st7701_swap_xy,
.get_swap_xy = st7701_get_swap_xy,
.get_mirror_x = st7701_get_mirror_x,
.get_mirror_y = st7701_get_mirror_y,
.set_gap = nullptr,
.invert_color = st7701_invert_color,
.disp_on_off = st7701_disp_on_off,
.disp_sleep = nullptr,
.get_color_format = st7701_get_color_format,
.get_resolution_x = st7701_get_resolution_x,
.get_resolution_y = st7701_get_resolution_y,
.get_frame_buffer = st7701_get_frame_buffer,
.get_frame_buffer_count = st7701_get_frame_buffer_count,
.get_backlight = st7701_get_backlight,
.has_capability = st7701_has_capability,
};
Driver st7701_driver = {
.name = "st7701",
.compatible = (const char*[]) { "sitronix,st7701", nullptr },
.start_device = start,
.stop_device = stop,
.api = &st7701_display_api,
.device_type = &DISPLAY_TYPE,
.owner = &st7701_module,
.internal = nullptr
};
#endif // SOC_LCD_RGB_SUPPORTED