@@ -0,0 +1,7 @@
+# ST7701 panel driven over MIPI-DSI (video mode) through lvgl_micropython's
+# lcd_bus.DSIBus. Used by the Waveshare ESP32-P4-WIFI6-Touch-LCD-4.3.
+from .st7701_dsi import ST7701_DSI
+
+__all__ = [
+    'ST7701_DSI',
+]
@@ -0,0 +1,68 @@
+# ST7701 register setup for the Waveshare ESP32-P4-WIFI6-Touch-LCD-4.3 panel
+# (480x800, 2-lane MIPI-DSI, RGB565). The bank/gamma/power/timing values are
+# the vendor's, transcribed from vendor_specific_init_default in Waveshare's
+# BSP (waveshare/esp32_p4_wifi6_touch_lcd_4_3 1.0.1, esp32_p4_wifi6_touch_lcd_4_3.c);
+# the first three writes are the bank-0 MADCTL/COLMOD setup Espressif's
+# esp_lcd_st7701 MIPI driver sends ahead of the vendor table.
+
+import time
+
+# (command, parameters or None, delay in ms after the command)
+_SEQ = (
+    (0xFF, b'\x77\x01\x00\x00\x00', 0),  # Command2 off: bank 0
+    (0x36, b'\x00', 0),                  # MADCTL: RGB order, no mirroring
+    (0x3A, b'\x55', 0),                  # COLMOD: 16 bits per pixel (RGB565)
+
+    (0xFF, b'\x77\x01\x00\x00\x13', 0),  # Command2 BK3
+    (0xEF, b'\x08', 0),
+
+    (0xFF, b'\x77\x01\x00\x00\x10', 0),  # Command2 BK0
+    (0xC0, b'\x63\x00', 0),              # display line setting
+    (0xC1, b'\x0D\x02', 0),              # porch control
+    (0xC2, b'\x17\x08', 0),              # inversion + frame rate
+    (0xCC, b'\x10', 0),
+    (0xB0, b'\x40\xC9\x94\x0E\x10\x05\x0B\x09\x08\x26\x04\x52\x10\x69\x6B\x69', 0),  # positive gamma
+    (0xB1, b'\x40\xD2\x98\x0C\x92\x07\x09\x08\x07\x25\x02\x0E\x0C\x6E\x78\x55', 0),  # negative gamma
+
+    (0xFF, b'\x77\x01\x00\x00\x11', 0),  # Command2 BK1
+    (0xB0, b'\x5D', 0),                  # VOP amplitude
+    (0xB1, b'\x4E', 0),                  # VCOM amplitude
+    (0xB2, b'\x87', 0),                  # VGH
+    (0xB3, b'\x80', 0),
+    (0xB5, b'\x4E', 0),                  # VGL
+    (0xB7, b'\x85', 0),                  # power control 1
+    (0xB8, b'\x21', 0),                  # power control 2
+    (0xB9, b'\x10\x1F', 0),
+    (0xBB, b'\x03', 0),
+    (0xBC, b'\x00', 0),
+    (0xC1, b'\x78', 0),                  # source pre-drive timing
+    (0xC2, b'\x78', 0),                  # source EQ2
+    (0xD0, b'\x88', 0),                  # MIPI setting 1
+    (0xE0, b'\x00\x3A\x02', 0),
+    (0xE1, b'\x04\xA0\x00\xA0\x05\xA0\x00\xA0\x00\x40\x40', 0),
+    (0xE2, b'\x30\x00\x40\x40\x32\xA0\x00\xA0\x00\xA0\x00\xA0\x00', 0),
+    (0xE3, b'\x00\x00\x33\x33', 0),
+    (0xE4, b'\x44\x44', 0),
+    (0xE5, b'\x09\x2E\xA0\xA0\x0B\x30\xA0\xA0\x05\x2A\xA0\xA0\x07\x2C\xA0\xA0', 0),
+    (0xE6, b'\x00\x00\x33\x33', 0),
+    (0xE7, b'\x44\x44', 0),
+    (0xE8, b'\x08\x2D\xA0\xA0\x0A\x2F\xA0\xA0\x04\x29\xA0\xA0\x06\x2B\xA0\xA0', 0),
+    (0xEB, b'\x00\x00\x4E\x4E\x00\x00\x00', 0),
+    (0xEC, b'\x08\x01', 0),
+    (0xED, b'\xB0\x2B\x98\xA4\x56\x7F\xFF\xFF\xFF\xFF\xF7\x65\x4A\x89\xB2\x0B', 0),
+    (0xEF, b'\x08\x08\x08\x45\x3F\x54', 0),
+
+    (0xFF, b'\x77\x01\x00\x00\x00', 0),  # back to bank 0
+    (0x11, None, 120),                   # SLPOUT, then the mandatory 120 ms
+    (0x29, None, 0),                     # DISPON
+)
+
+
+def init(self):
+    for cmd, params, delay in _SEQ:
+        if params is None:
+            self.set_params(cmd)
+        else:
+            self.set_params(cmd, params)
+        if delay:
+            time.sleep_ms(delay)  # NOQA
@@ -0,0 +1,118 @@
+import time
+
+from micropython import const  # NOQA
+import lvgl as lv
+import display_driver_framework
+
+STATE_HIGH = display_driver_framework.STATE_HIGH
+STATE_LOW = display_driver_framework.STATE_LOW
+STATE_PWM = display_driver_framework.STATE_PWM
+
+BYTE_ORDER_RGB = display_driver_framework.BYTE_ORDER_RGB
+BYTE_ORDER_BGR = display_driver_framework.BYTE_ORDER_BGR
+
+_RDDID = const(0x04)  # Read Display ID
+
+
+class ST7701_DSI(display_driver_framework.DisplayDriver):
+    """ST7701 over MIPI-DSI in video mode (lcd_bus.DSIBus).
+
+    The DSI bus owns two screen-sized frame buffers that LVGL renders into
+    directly and the SoC's DPI DMA scans out continuously, so unlike the
+    SPI/I80 panels there is no window addressing (CASET/RASET/RAMWR) and no
+    per-flush pixel transfer here. What this driver does is bring the panel
+    up: hardware reset, then the DCS register setup (bank selects, gamma,
+    power, timing, SLPOUT, DISPON) over the same DSI link. The bus starts
+    the video stream on the first flush, i.e. after that setup, the order
+    Espressif's own esp_lcd_st7701 MIPI driver uses.
+
+    Rotation is not supported: the ST7701 has no row/column exchange for
+    the video interface, so the display runs in the panel's native
+    orientation.
+    """
+
+    STATE_HIGH = STATE_HIGH
+    STATE_LOW = STATE_LOW
+    STATE_PWM = STATE_PWM
+    BYTE_ORDER_RGB = BYTE_ORDER_RGB
+    BYTE_ORDER_BGR = BYTE_ORDER_BGR
+
+    _INVOFF = 0x20  # Color Inversion Off
+    _INVON = 0x21   # Color Inversion On
+
+    def __init__(
+        self,
+        data_bus,
+        display_width,
+        display_height,
+        frame_buffer1,
+        frame_buffer2=None,
+        reset_pin=None,
+        reset_state=STATE_LOW,
+        power_pin=None,
+        power_on_state=STATE_HIGH,
+        backlight_pin=None,
+        backlight_on_state=STATE_HIGH,
+        color_byte_order=BYTE_ORDER_RGB,
+        color_space=lv.COLOR_FORMAT.RGB565,
+    ):
+        self.panel_id = None
+
+        super().__init__(
+            data_bus=data_bus,
+            display_width=display_width,
+            display_height=display_height,
+            frame_buffer1=frame_buffer1,
+            frame_buffer2=frame_buffer2,
+            reset_pin=reset_pin,
+            reset_state=reset_state,
+            power_pin=power_pin,
+            power_on_state=power_on_state,
+            backlight_pin=backlight_pin,
+            backlight_on_state=backlight_on_state,
+            offset_x=0,
+            offset_y=0,
+            color_byte_order=color_byte_order,
+            color_space=color_space,
+            rgb565_byte_swap=False,
+            _cmd_bits=8,
+            _param_bits=8,
+            _init_bus=True,  # creates the DSI bus, the DBI command IO and the DPI panel (frame buffers)
+        )
+
+    def init(self, type=None):  # NOQA
+        # Hardware reset: reset_state is the active level (the framework
+        # holds it for 120 ms), then give the controller time to come up.
+        self.reset()
+        time.sleep_ms(120)  # NOQA
+
+        # The ID read is the first traffic over the link, a cheap check that
+        # the panel answers before the long register setup.
+        try:
+            buf = bytearray(3)
+            self.get_params(_RDDID, buf)
+            self.panel_id = bytes(buf)
+        except Exception as e:  # NOQA
+            print('ST7701_DSI: panel ID read failed: %s' % e)
+
+        from . import _st7701_dsi_init
+        _st7701_dsi_init.init(self)
+
+        # No window to set: the whole frame buffer is what the panel shows.
+        self._initilized = True
+
+    def set_params(self, cmd, params=None):
+        self._data_bus.tx_param(cmd, params)
+
+    def get_params(self, cmd, params):
+        self._data_bus.rx_param(cmd, params)
+
+    def _set_memory_location(self, x1, y1, x2, y2):  # NOQA
+        # video-mode panel: no CASET/RASET/RAMWR
+        return -1
+
+    def _on_size_change(self, _):
+        # Track LVGL's idea of the size only; MADCTL cannot rotate this panel.
+        self._rotation = self._disp_drv.get_rotation()
+        self._width = self._disp_drv.get_horizontal_resolution()
+        self._height = self._disp_drv.get_vertical_resolution()
@@ -91,8 +91,9 @@ def __init__(
 
         if isinstance(interrupt_pin, int) and _USE_INTERRUPTS:
             interrupt_pin = machine.Pin(interrupt_pin, machine.Pin.IN)
-        else:
+        elif isinstance(interrupt_pin, int):
             interrupt_pin = machine.Pin(interrupt_pin, machine.Pin.OUT)
+        # else: INT not wired to the MCU (e.g. Waveshare ESP32-P4 4.3), leave it None
 
         self._reset_pin = reset_pin
         self._interrupt_pin = interrupt_pin
 
@@ -2,14 +2,124 @@
 
 logger = logging.getLogger(__name__)
 
-# Waveshare ESP32-P4-WIFI6-Touch-LCD-4.3 — bring-up stage 1 (#307):
-# ESP32-P4 + ESP32-C6 Wi-Fi co-processor over SDIO (handled by MicroPython's
-# C6_WIFI board variant), 4.3" 480x800 MIPI-DSI panel (ST7701, 2 lanes),
-# GT911 touch on I2C (SDA=7, SCL=8), ES8311/ES7210 audio, SD card, camera.
+if __debug__: logger.debug("waveshare_esp32_p4_wifi6_touch_lcd_4_3.py initialization")
+# Hardware initialization for the Waveshare ESP32-P4-WIFI6-Touch-LCD-4.3:
+# ESP32-P4 (RISC-V) with an ESP32-C6 Wi-Fi 6 / BLE co-processor over SDIO
+# (esp_hosted), 32 MB flash, 32 MB PSRAM, 4.3" 480x800 portrait IPS over
+# 2-lane MIPI-DSI (ST7701), GT911 capacitive touch, ES8311 codec + ES7210
+# microphone ADC, TF card slot (4-bit SDIO), MIPI-CSI camera connector,
+# USB host port.
 #
-# The MIPI-DSI display needs a DSI bus in lvgl_micropython that is not
-# wired up yet, so this stage registers no display: MicroPythonOS stops at
-# init_rootscreen() and leaves the REPL usable for the Wi-Fi/boot work.
-# Display, touch, audio follow in later stages.
+# Manufacturer's wiki: https://www.waveshare.com/wiki/ESP32-P4-WIFI6-Touch-LCD-4.3
+# Pins, panel timings and the ST7701 register table come from Waveshare's
+# ESP-IDF BSP (waveshare/esp32_p4_wifi6_touch_lcd_4_3 1.0.1).
+#
+# The panel is used in its native portrait orientation (480 wide, 800 high):
+# the ST7701 cannot swap rows and columns for the video interface, and the
+# enclosure's cable/button placement suits portrait.
+
+import time
+
+import i2c
+import lcd_bus
+import lvgl as lv
+import machine
+import mpos.ui
+from drivers.display.st7701_dsi import ST7701_DSI
+import drivers.indev.gt911 as gt911
+from mpos import InputManager
+
+LCD_WIDTH = 480
+LCD_HEIGHT = 800
+LCD_RST = 27
+LCD_BL = 26          # backlight enable, PWM dimmable, ACTIVE LOW (the BSP drives its LEDC channel inverted)
+
+I2C_SDA = 7
+I2C_SCL = 8
+I2C_FREQ = 400000
+
+TOUCH_ADDRS = (0x5D, 0x14)   # GT911; the strap at reset picks one
+
+# === BACKLIGHT ===
+# Kept off (pin high) until the panel shows its first frame, so the boot does
+# not flash a white screen.
+_backlight = machine.PWM(machine.Pin(LCD_BL), freq=5000, duty_u16=65535)
+_backlight_percent = 0
+
+
+def _set_backlight(percent):
+    global _backlight_percent
+    percent = max(0, min(100, int(percent)))
+    _backlight_percent = percent
+    _backlight.duty_u16(65535 - percent * 65535 // 100)  # active low: 0% = pin high
+
+
+def _get_backlight():
+    return _backlight_percent
+
+
+# === DISPLAY (ST7701 over MIPI-DSI) ===
+# Video mode: the DPI DMA scans two screen-sized frame buffers (in PSRAM) out
+# to the panel continuously, LVGL renders straight into them. The DSI PHY is
+# powered by the P4's internal LDO channel 3.
+display_bus = lcd_bus.DSIBus(
+    bus_id=0,
+    data_lanes=2,
+    freq=500,             # lane bit rate, Mbps
+    dpi_clock_freq=30,    # DPI pixel clock, MHz
+    virtual_channel=0,
+    hsync_back_porch=42,
+    hsync_pulse_width=12,
+    hsync_front_porch=42,
+    vsync_back_porch=2,
+    vsync_pulse_width=8,
+    vsync_front_porch=60,
+    phy_ldo_channel=3,
+    phy_ldo_voltage_mv=2500,
+)
+
+_FB_SIZE = const(480 * 800 * 2)  # RGB565, whole screen: 768000 bytes
+fb1 = display_bus.allocate_framebuffer(_FB_SIZE, lcd_bus.MEMORY_SPIRAM)
+fb2 = display_bus.allocate_framebuffer(_FB_SIZE, lcd_bus.MEMORY_SPIRAM)
+
+mpos.ui.main_display = ST7701_DSI(
+    data_bus=display_bus,
+    frame_buffer1=fb1,
+    frame_buffer2=fb2,
+    display_width=LCD_WIDTH,
+    display_height=LCD_HEIGHT,
+    reset_pin=LCD_RST,
+    reset_state=ST7701_DSI.STATE_LOW,
+    color_space=lv.COLOR_FORMAT.RGB565,
+    color_byte_order=ST7701_DSI.BYTE_ORDER_RGB,
+)  # triggers lv.init()
+mpos.ui.main_display.init()
+if __debug__: logger.debug("ST7701 panel ID: %s", mpos.ui.main_display.panel_id)
+
+mpos.ui.main_display.set_backlight = _set_backlight
+mpos.ui.main_display.get_backlight = _get_backlight
+
+# Push a first frame now: the bus starts the DSI video stream on the first
+# flush, and the backlight only goes on once the panel has something to show.
+try:
+    lv.refr_now(None)
+except Exception as e:
+    logger.error("initial refresh failed: %s" % (e))
+mpos.ui.main_display.set_backlight(100)
+
+# === TOUCH (GT911) ===
+# Neither its reset nor its interrupt line is wired to the P4 on this board,
+# so the controller is polled at whichever address its strap selected.
+i2c_bus = i2c.I2C.Bus(host=0, scl=I2C_SCL, sda=I2C_SDA, freq=I2C_FREQ, use_locks=False)
+try:
+    present = i2c_bus.scan()
+    touch_addr = next((a for a in TOUCH_ADDRS if a in present), None)
+    if touch_addr is None:
+        raise RuntimeError("GT911 not found on I2C (devices: %s)" % [hex(a) for a in present])
+    touch_dev = i2c.I2C.Device(bus=i2c_bus, dev_id=touch_addr, reg_bits=gt911.BITS)
+    indev = gt911.GT911(touch_dev)
+    InputManager.register_indev(indev)
+except Exception as e:
+    logger.error("GT911 init failed: %s" % (e))
 
-logger.warning("Waveshare ESP32-P4-WIFI6-Touch-LCD-4.3: stage-1 board file, no display driver yet")
+if __debug__: logger.debug("waveshare_esp32_p4_wifi6_touch_lcd_4_3.py finished")
@@ -400,6 +400,12 @@ if [ "$target" == "esp32" -o "$target" == "esp32s3" -o "$target" == "unphone" -o
 		BOARD_VARIANT=C6_WIFI
 		partition_size=4194304
 		flash_size="32"
+		# PSRAM at 200 MHz (ESP-IDF 5.5 still labels that speed experimental)
+		# and the 256 KB L2 cache with 128-byte lines, as in Waveshare's and
+		# Espressif's P4 display examples: the MIPI-DSI panel is scanned out
+		# of PSRAM continuously (480x800 RGB565 at 60 Hz is 46 MB/s) and
+		# MicroPython's default 20 MHz PSRAM clock cannot feed it.
+		extra_configs="CONFIG_IDF_EXPERIMENTAL_FEATURES=y CONFIG_SPIRAM_SPEED_200M=y CONFIG_CACHE_L2_CACHE_256KB=y CONFIG_CACHE_L2_CACHE_LINE_128B=y"
 	else # esp32s3 or unphone
         if [ "$target" == "unphone" ]; then
             flash_size="8"