esphome 2025.8.4__py3-none-any.whl → 2025.9.0b1__py3-none-any.whl

esphome/components/mipi_rgb/display.py

@@ -0,0 +1,321 @@
+import importlib
+import pkgutil
+
+from esphome import pins
+import esphome.codegen as cg
+from esphome.components import display, spi
+from esphome.components.const import (
+    BYTE_ORDER_BIG,
+    BYTE_ORDER_LITTLE,
+    CONF_BYTE_ORDER,
+    CONF_DRAW_ROUNDING,
+)
+from esphome.components.display import CONF_SHOW_TEST_CARD
+from esphome.components.esp32 import const, only_on_variant
+from esphome.components.mipi import (
+    COLOR_ORDERS,
+    CONF_DE_PIN,
+    CONF_HSYNC_BACK_PORCH,
+    CONF_HSYNC_FRONT_PORCH,
+    CONF_HSYNC_PULSE_WIDTH,
+    CONF_PCLK_PIN,
+    CONF_PIXEL_MODE,
+    CONF_USE_AXIS_FLIPS,
+    CONF_VSYNC_BACK_PORCH,
+    CONF_VSYNC_FRONT_PORCH,
+    CONF_VSYNC_PULSE_WIDTH,
+    MODE_BGR,
+    PIXEL_MODE_16BIT,
+    PIXEL_MODE_18BIT,
+    DriverChip,
+    dimension_schema,
+    map_sequence,
+    power_of_two,
+    requires_buffer,
+)
+from esphome.components.rpi_dpi_rgb.display import (
+    CONF_PCLK_FREQUENCY,
+    CONF_PCLK_INVERTED,
+)
+import esphome.config_validation as cv
+from esphome.const import (
+    CONF_BLUE,
+    CONF_COLOR_ORDER,
+    CONF_CS_PIN,
+    CONF_DATA_PINS,
+    CONF_DATA_RATE,
+    CONF_DC_PIN,
+    CONF_DIMENSIONS,
+    CONF_ENABLE_PIN,
+    CONF_GREEN,
+    CONF_HSYNC_PIN,
+    CONF_ID,
+    CONF_IGNORE_STRAPPING_WARNING,
+    CONF_INIT_SEQUENCE,
+    CONF_INVERT_COLORS,
+    CONF_LAMBDA,
+    CONF_MIRROR_X,
+    CONF_MIRROR_Y,
+    CONF_MODEL,
+    CONF_NUMBER,
+    CONF_RED,
+    CONF_RESET_PIN,
+    CONF_ROTATION,
+    CONF_SPI_ID,
+    CONF_SWAP_XY,
+    CONF_TRANSFORM,
+    CONF_VSYNC_PIN,
+    CONF_WIDTH,
+)
+from esphome.final_validate import full_config
+
+from ..spi import CONF_SPI_MODE, SPI_DATA_RATE_SCHEMA, SPI_MODE_OPTIONS, SPIComponent
+from . import models
+
+DEPENDENCIES = ["esp32", "psram"]
+
+mipi_rgb_ns = cg.esphome_ns.namespace("mipi_rgb")
+mipi_rgb = mipi_rgb_ns.class_("MipiRgb", display.Display, cg.Component)
+mipi_rgb_spi = mipi_rgb_ns.class_(
+    "MipiRgbSpi", mipi_rgb, display.Display, cg.Component, spi.SPIDevice
+)
+ColorOrder = display.display_ns.enum("ColorMode")
+
+DATA_PIN_SCHEMA = pins.internal_gpio_output_pin_schema
+
+DriverChip("CUSTOM")
+
+# Import all models dynamically from the models package
+
+for module_info in pkgutil.iter_modules(models.__path__):
+    importlib.import_module(f".models.{module_info.name}", package=__package__)
+
+MODELS = DriverChip.get_models()
+
+
+def data_pin_validate(value):
+    """
+    It is safe to use strapping pins as RGB output data bits, as they are outputs only,
+    and not initialised until after boot.
+    """
+    if not isinstance(value, dict):
+        try:
+            return DATA_PIN_SCHEMA(
+                {CONF_NUMBER: value, CONF_IGNORE_STRAPPING_WARNING: True}
+            )
+        except cv.Invalid:
+            pass
+    return DATA_PIN_SCHEMA(value)
+
+
+def data_pin_set(length):
+    return cv.All(
+        [data_pin_validate],
+        cv.Length(min=length, max=length, msg=f"Exactly {length} data pins required"),
+    )
+
+
+def model_schema(config):
+    model = MODELS[config[CONF_MODEL].upper()]
+    if transforms := model.transforms:
+        transform = cv.Schema({cv.Required(x): cv.boolean for x in transforms})
+        for x in (CONF_SWAP_XY, CONF_MIRROR_X, CONF_MIRROR_Y):
+            if x not in transforms:
+                transform = transform.extend(
+                    {cv.Optional(x): cv.invalid(f"{x} not supported by this model")}
+                )
+    else:
+        transform = cv.invalid("This model does not support transforms")
+
+    # RPI model does not use an init sequence, indicates with empty list
+    if model.initsequence is None:
+        # Custom model requires an init sequence
+        iseqconf = cv.Required(CONF_INIT_SEQUENCE)
+        uses_spi = True
+    else:
+        iseqconf = cv.Optional(CONF_INIT_SEQUENCE)
+        uses_spi = CONF_INIT_SEQUENCE in config or len(model.initsequence) != 0
+    swap_xy = config.get(CONF_TRANSFORM, {}).get(CONF_SWAP_XY, False)
+
+    # Dimensions are optional if the model has a default width and the swap_xy transform is not overridden
+    cv_dimensions = (
+        cv.Optional if model.get_default(CONF_WIDTH) and not swap_xy else cv.Required
+    )
+    pixel_modes = (PIXEL_MODE_16BIT, PIXEL_MODE_18BIT, "16", "18")
+    schema = display.FULL_DISPLAY_SCHEMA.extend(
+        {
+            model.option(CONF_RESET_PIN, cv.UNDEFINED): pins.gpio_output_pin_schema,
+            cv.GenerateID(): cv.declare_id(mipi_rgb_spi if uses_spi else mipi_rgb),
+            cv_dimensions(CONF_DIMENSIONS): dimension_schema(
+                model.get_default(CONF_DRAW_ROUNDING, 1)
+            ),
+            model.option(CONF_ENABLE_PIN, cv.UNDEFINED): cv.ensure_list(
+                pins.gpio_output_pin_schema
+            ),
+            model.option(CONF_COLOR_ORDER, MODE_BGR): cv.enum(COLOR_ORDERS, upper=True),
+            model.option(CONF_DRAW_ROUNDING, 2): power_of_two,
+            model.option(CONF_PIXEL_MODE, PIXEL_MODE_16BIT): cv.one_of(
+                *pixel_modes, lower=True
+            ),
+            model.option(CONF_TRANSFORM, cv.UNDEFINED): transform,
+            cv.Required(CONF_MODEL): cv.one_of(model.name, upper=True),
+            model.option(CONF_INVERT_COLORS, False): cv.boolean,
+            model.option(CONF_USE_AXIS_FLIPS, True): cv.boolean,
+            model.option(CONF_PCLK_FREQUENCY, "40MHz"): cv.All(
+                cv.frequency, cv.Range(min=4e6, max=100e6)
+            ),
+            model.option(CONF_PCLK_INVERTED, True): cv.boolean,
+            iseqconf: cv.ensure_list(map_sequence),
+            model.option(CONF_BYTE_ORDER, BYTE_ORDER_BIG): cv.one_of(
+                BYTE_ORDER_LITTLE, BYTE_ORDER_BIG, lower=True
+            ),
+            model.option(CONF_HSYNC_PULSE_WIDTH): cv.int_,
+            model.option(CONF_HSYNC_BACK_PORCH): cv.int_,
+            model.option(CONF_HSYNC_FRONT_PORCH): cv.int_,
+            model.option(CONF_VSYNC_PULSE_WIDTH): cv.int_,
+            model.option(CONF_VSYNC_BACK_PORCH): cv.int_,
+            model.option(CONF_VSYNC_FRONT_PORCH): cv.int_,
+            model.option(CONF_DATA_PINS): cv.Any(
+                data_pin_set(16),
+                cv.Schema(
+                    {
+                        cv.Required(CONF_RED): data_pin_set(5),
+                        cv.Required(CONF_GREEN): data_pin_set(6),
+                        cv.Required(CONF_BLUE): data_pin_set(5),
+                    }
+                ),
+            ),
+            model.option(
+                CONF_DE_PIN, cv.UNDEFINED
+            ): pins.internal_gpio_output_pin_schema,
+            model.option(CONF_PCLK_PIN): pins.internal_gpio_output_pin_schema,
+            model.option(CONF_HSYNC_PIN): pins.internal_gpio_output_pin_schema,
+            model.option(CONF_VSYNC_PIN): pins.internal_gpio_output_pin_schema,
+            model.option(CONF_RESET_PIN, cv.UNDEFINED): pins.gpio_output_pin_schema,
+        }
+    )
+    if uses_spi:
+        schema = schema.extend(
+            {
+                cv.GenerateID(CONF_SPI_ID): cv.use_id(SPIComponent),
+                model.option(CONF_DC_PIN, cv.UNDEFINED): pins.gpio_output_pin_schema,
+                model.option(CONF_DATA_RATE, "1MHz"): SPI_DATA_RATE_SCHEMA,
+                model.option(CONF_SPI_MODE, "MODE0"): cv.enum(
+                    SPI_MODE_OPTIONS, upper=True
+                ),
+                model.option(CONF_CS_PIN, cv.UNDEFINED): pins.gpio_output_pin_schema,
+            }
+        )
+    return schema
+
+
+def _config_schema(config):
+    config = cv.Schema(
+        {
+            cv.Required(CONF_MODEL): cv.one_of(*MODELS, upper=True),
+        },
+        extra=cv.ALLOW_EXTRA,
+    )(config)
+    schema = model_schema(config)
+    return cv.All(
+        schema,
+        only_on_variant(supported=[const.VARIANT_ESP32S3]),
+        cv.only_with_esp_idf,
+    )(config)
+
+
+CONFIG_SCHEMA = _config_schema
+
+
+def _final_validate(config):
+    global_config = full_config.get()
+
+    from esphome.components.lvgl import DOMAIN as LVGL_DOMAIN
+
+    if not requires_buffer(config) and LVGL_DOMAIN not in global_config:
+        # If no drawing methods are configured, and LVGL is not enabled, show a test card
+        config[CONF_SHOW_TEST_CARD] = True
+    if CONF_SPI_ID in config:
+        config = spi.final_validate_device_schema(
+            "mipi_rgb", require_miso=False, require_mosi=True
+        )(config)
+    return config
+
+
+FINAL_VALIDATE_SCHEMA = _final_validate
+
+
+async def to_code(config):
+    model = MODELS[config[CONF_MODEL].upper()]
+    width, height, _offset_width, _offset_height = model.get_dimensions(config)
+    var = cg.new_Pvariable(config[CONF_ID], width, height)
+    cg.add(var.set_model(model.name))
+    if enable_pin := config.get(CONF_ENABLE_PIN):
+        enable = [await cg.gpio_pin_expression(pin) for pin in enable_pin]
+        cg.add(var.set_enable_pins(enable))
+
+    if CONF_SPI_ID in config:
+        await spi.register_spi_device(var, config)
+        sequence, madctl = model.get_sequence(config)
+        cg.add(var.set_init_sequence(sequence))
+        cg.add(var.set_madctl(madctl))
+
+    cg.add(var.set_color_mode(COLOR_ORDERS[config[CONF_COLOR_ORDER]]))
+    cg.add(var.set_invert_colors(config[CONF_INVERT_COLORS]))
+    cg.add(var.set_hsync_pulse_width(config[CONF_HSYNC_PULSE_WIDTH]))
+    cg.add(var.set_hsync_back_porch(config[CONF_HSYNC_BACK_PORCH]))
+    cg.add(var.set_hsync_front_porch(config[CONF_HSYNC_FRONT_PORCH]))
+    cg.add(var.set_vsync_pulse_width(config[CONF_VSYNC_PULSE_WIDTH]))
+    cg.add(var.set_vsync_back_porch(config[CONF_VSYNC_BACK_PORCH]))
+    cg.add(var.set_vsync_front_porch(config[CONF_VSYNC_FRONT_PORCH]))
+    cg.add(var.set_pclk_inverted(config[CONF_PCLK_INVERTED]))
+    cg.add(var.set_pclk_frequency(config[CONF_PCLK_FREQUENCY]))
+    index = 0
+    dpins = []
+    if CONF_RED in config[CONF_DATA_PINS]:
+        red_pins = config[CONF_DATA_PINS][CONF_RED]
+        green_pins = config[CONF_DATA_PINS][CONF_GREEN]
+        blue_pins = config[CONF_DATA_PINS][CONF_BLUE]
+        if config[CONF_COLOR_ORDER] == "BGR":
+            dpins.extend(red_pins)
+            dpins.extend(green_pins)
+            dpins.extend(blue_pins)
+        else:
+            dpins.extend(blue_pins)
+            dpins.extend(green_pins)
+            dpins.extend(red_pins)
+        # swap bytes to match big-endian format
+        dpins = dpins[8:16] + dpins[0:8]
+    else:
+        dpins = config[CONF_DATA_PINS]
+    for index, pin in enumerate(dpins):
+        data_pin = await cg.gpio_pin_expression(pin)
+        cg.add(var.add_data_pin(data_pin, index))
+
+    if dc_pin := config.get(CONF_DC_PIN):
+        dc = await cg.gpio_pin_expression(dc_pin)
+        cg.add(var.set_dc_pin(dc))
+
+    if reset_pin := config.get(CONF_RESET_PIN):
+        reset = await cg.gpio_pin_expression(reset_pin)
+        cg.add(var.set_reset_pin(reset))
+
+    if model.rotation_as_transform(config):
+        config[CONF_ROTATION] = 0
+
+    if de_pin := config.get(CONF_DE_PIN):
+        pin = await cg.gpio_pin_expression(de_pin)
+        cg.add(var.set_de_pin(pin))
+    pin = await cg.gpio_pin_expression(config[CONF_PCLK_PIN])
+    cg.add(var.set_pclk_pin(pin))
+    pin = await cg.gpio_pin_expression(config[CONF_HSYNC_PIN])
+    cg.add(var.set_hsync_pin(pin))
+    pin = await cg.gpio_pin_expression(config[CONF_VSYNC_PIN])
+    cg.add(var.set_vsync_pin(pin))
+
+    await display.register_display(var, config)
+    if lamb := config.get(CONF_LAMBDA):
+        lambda_ = await cg.process_lambda(
+            lamb, [(display.DisplayRef, "it")], return_type=cg.void
+        )
+        cg.add(var.set_writer(lambda_))

esphome/components/mipi_rgb/mipi_rgb.cpp

@@ -0,0 +1,388 @@
+#ifdef USE_ESP32_VARIANT_ESP32S3
+#include "mipi_rgb.h"
+#include "esphome/core/log.h"
+#include "esphome/core/hal.h"
+#include "esp_lcd_panel_rgb.h"
+
+namespace esphome {
+namespace mipi_rgb {
+
+static const uint8_t DELAY_FLAG = 0xFF;
+static constexpr uint8_t MADCTL_MY = 0x80;     // Bit 7 Bottom to top
+static constexpr uint8_t MADCTL_MX = 0x40;     // Bit 6 Right to left
+static constexpr uint8_t MADCTL_MV = 0x20;     // Bit 5 Swap axes
+static constexpr uint8_t MADCTL_ML = 0x10;     // Bit 4 Refresh bottom to top
+static constexpr uint8_t MADCTL_BGR = 0x08;    // Bit 3 Blue-Green-Red pixel order
+static constexpr uint8_t MADCTL_XFLIP = 0x02;  // Mirror the display horizontally
+static constexpr uint8_t MADCTL_YFLIP = 0x01;  // Mirror the display vertically
+
+void MipiRgb::setup_enables_() {
+  if (!this->enable_pins_.empty()) {
+    for (auto *pin : this->enable_pins_) {
+      pin->setup();
+      pin->digital_write(true);
+    }
+    delay(10);
+  }
+  if (this->reset_pin_ != nullptr) {
+    this->reset_pin_->setup();
+    this->reset_pin_->digital_write(true);
+    delay(5);
+    this->reset_pin_->digital_write(false);
+    delay(5);
+    this->reset_pin_->digital_write(true);
+  }
+}
+
+#ifdef USE_SPI
+void MipiRgbSpi::setup() {
+  this->setup_enables_();
+  this->spi_setup();
+  this->write_init_sequence_();
+  this->common_setup_();
+}
+void MipiRgbSpi::write_command_(uint8_t value) {
+  this->enable();
+  if (this->dc_pin_ == nullptr) {
+    this->write(value, 9);
+  } else {
+    this->dc_pin_->digital_write(false);
+    this->write_byte(value);
+    this->dc_pin_->digital_write(true);
+  }
+  this->disable();
+}
+
+void MipiRgbSpi::write_data_(uint8_t value) {
+  this->enable();
+  if (this->dc_pin_ == nullptr) {
+    this->write(value | 0x100, 9);
+  } else {
+    this->dc_pin_->digital_write(true);
+    this->write_byte(value);
+  }
+  this->disable();
+}
+
+/**
+ * this relies upon the init sequence being well-formed, which is guaranteed by the Python init code.
+ */
+
+void MipiRgbSpi::write_init_sequence_() {
+  size_t index = 0;
+  auto &vec = this->init_sequence_;
+  while (index != vec.size()) {
+    if (vec.size() - index < 2) {
+      this->mark_failed("Malformed init sequence");
+      return;
+    }
+    uint8_t cmd = vec[index++];
+    uint8_t x = vec[index++];
+    if (x == DELAY_FLAG) {
+      ESP_LOGD(TAG, "Delay %dms", cmd);
+      delay(cmd);
+    } else {
+      uint8_t num_args = x & 0x7F;
+      if (vec.size() - index < num_args) {
+        this->mark_failed("Malformed init sequence");
+        return;
+      }
+      if (cmd == SLEEP_OUT) {
+        delay(120);  // NOLINT
+      }
+      const auto *ptr = vec.data() + index;
+      ESP_LOGD(TAG, "Write command %02X, length %d, byte(s) %s", cmd, num_args,
+               format_hex_pretty(ptr, num_args, '.', false).c_str());
+      index += num_args;
+      this->write_command_(cmd);
+      while (num_args-- != 0)
+        this->write_data_(*ptr++);
+      if (cmd == SLEEP_OUT)
+        delay(10);
+    }
+  }
+  // this->spi_teardown();  // SPI not needed after this
+  this->init_sequence_.clear();
+  delay(10);
+}
+
+void MipiRgbSpi::dump_config() {
+  MipiRgb::dump_config();
+  LOG_PIN("  CS Pin: ", this->cs_);
+  LOG_PIN("  DC Pin: ", this->dc_pin_);
+  ESP_LOGCONFIG(TAG,
+                "  SPI Data rate: %uMHz"
+                "\n  Mirror X: %s"
+                "\n  Mirror Y: %s"
+                "\n  Swap X/Y: %s"
+                "\n  Color Order: %s",
+                (unsigned) (this->data_rate_ / 1000000), YESNO(this->madctl_ & (MADCTL_XFLIP | MADCTL_MX)),
+                YESNO(this->madctl_ & (MADCTL_YFLIP | MADCTL_MY | MADCTL_ML)), YESNO(this->madctl_ & MADCTL_MV),
+                this->madctl_ & MADCTL_BGR ? "BGR" : "RGB");
+}
+
+#endif  // USE_SPI
+
+void MipiRgb::setup() {
+  this->setup_enables_();
+  this->common_setup_();
+}
+
+void MipiRgb::common_setup_() {
+  esp_lcd_rgb_panel_config_t config{};
+  config.flags.fb_in_psram = 1;
+  config.bounce_buffer_size_px = this->width_ * 10;
+  config.num_fbs = 1;
+  config.timings.h_res = this->width_;
+  config.timings.v_res = this->height_;
+  config.timings.hsync_pulse_width = this->hsync_pulse_width_;
+  config.timings.hsync_back_porch = this->hsync_back_porch_;
+  config.timings.hsync_front_porch = this->hsync_front_porch_;
+  config.timings.vsync_pulse_width = this->vsync_pulse_width_;
+  config.timings.vsync_back_porch = this->vsync_back_porch_;
+  config.timings.vsync_front_porch = this->vsync_front_porch_;
+  config.timings.flags.pclk_active_neg = this->pclk_inverted_;
+  config.timings.pclk_hz = this->pclk_frequency_;
+  config.clk_src = LCD_CLK_SRC_PLL160M;
+  size_t data_pin_count = sizeof(this->data_pins_) / sizeof(this->data_pins_[0]);
+  for (size_t i = 0; i != data_pin_count; i++) {
+    config.data_gpio_nums[i] = this->data_pins_[i]->get_pin();
+  }
+  config.data_width = data_pin_count;
+  config.disp_gpio_num = -1;
+  config.hsync_gpio_num = this->hsync_pin_->get_pin();
+  config.vsync_gpio_num = this->vsync_pin_->get_pin();
+  if (this->de_pin_) {
+    config.de_gpio_num = this->de_pin_->get_pin();
+  } else {
+    config.de_gpio_num = -1;
+  }
+  config.pclk_gpio_num = this->pclk_pin_->get_pin();
+  esp_err_t err = esp_lcd_new_rgb_panel(&config, &this->handle_);
+  if (err == ESP_OK)
+    err = esp_lcd_panel_reset(this->handle_);
+  if (err == ESP_OK)
+    err = esp_lcd_panel_init(this->handle_);
+  if (err != ESP_OK) {
+    auto msg = str_sprintf("lcd setup failed: %s", esp_err_to_name(err));
+    this->mark_failed(msg.c_str());
+  }
+  ESP_LOGCONFIG(TAG, "MipiRgb setup complete");
+}
+
+void MipiRgb::loop() {
+  if (this->handle_ != nullptr)
+    esp_lcd_rgb_panel_restart(this->handle_);
+}
+
+void MipiRgb::update() {
+  if (this->is_failed())
+    return;
+  if (this->auto_clear_enabled_) {
+    this->clear();
+  }
+  if (this->show_test_card_) {
+    this->test_card();
+  } else if (this->page_ != nullptr) {
+    this->page_->get_writer()(*this);
+  } else if (this->writer_.has_value()) {
+    (*this->writer_)(*this);
+  } else {
+    this->stop_poller();
+  }
+  if (this->buffer_ == nullptr || this->x_low_ > this->x_high_ || this->y_low_ > this->y_high_)
+    return;
+  ESP_LOGV(TAG, "x_low %d, y_low %d, x_high %d, y_high %d", this->x_low_, this->y_low_, this->x_high_, this->y_high_);
+  int w = this->x_high_ - this->x_low_ + 1;
+  int h = this->y_high_ - this->y_low_ + 1;
+  this->write_to_display_(this->x_low_, this->y_low_, w, h, reinterpret_cast<const uint8_t *>(this->buffer_),
+                          this->x_low_, this->y_low_, this->width_ - w - this->x_low_);
+  // invalidate watermarks
+  this->x_low_ = this->width_;
+  this->y_low_ = this->height_;
+  this->x_high_ = 0;
+  this->y_high_ = 0;
+}
+
+void MipiRgb::draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *ptr, display::ColorOrder order,
+                             display::ColorBitness bitness, bool big_endian, int x_offset, int y_offset, int x_pad) {
+  if (w <= 0 || h <= 0 || this->is_failed())
+    return;
+  // if color mapping is required, pass the buck.
+  // note that endianness is not considered here - it is assumed to match!
+  if (bitness != display::COLOR_BITNESS_565) {
+    Display::draw_pixels_at(x_start, y_start, w, h, ptr, order, bitness, big_endian, x_offset, y_offset, x_pad);
+    this->write_to_display_(x_start, y_start, w, h, reinterpret_cast<const uint8_t *>(this->buffer_), x_start, y_start,
+                            this->width_ - w - x_start);
+  } else {
+    this->write_to_display_(x_start, y_start, w, h, ptr, x_offset, y_offset, x_pad);
+  }
+}
+
+void MipiRgb::write_to_display_(int x_start, int y_start, int w, int h, const uint8_t *ptr, int x_offset, int y_offset,
+                                int x_pad) {
+  esp_err_t err = ESP_OK;
+  auto stride = (x_offset + w + x_pad) * 2;
+  ptr += y_offset * stride + x_offset * 2;  // skip to the first pixel
+  // x_ and y_offset are offsets into the source buffer, unrelated to our own offsets into the display.
+  if (x_offset == 0 && x_pad == 0) {
+    err = esp_lcd_panel_draw_bitmap(this->handle_, x_start, y_start, x_start + w, y_start + h, ptr);
+  } else {
+    // draw line by line
+    for (int y = 0; y != h; y++) {
+      err = esp_lcd_panel_draw_bitmap(this->handle_, x_start, y + y_start, x_start + w, y + y_start + 1, ptr);
+      if (err != ESP_OK)
+        break;
+      ptr += stride;  // next line
+    }
+  }
+  if (err != ESP_OK)
+    ESP_LOGE(TAG, "lcd_lcd_panel_draw_bitmap failed: %s", esp_err_to_name(err));
+}
+
+bool MipiRgb::check_buffer_() {
+  if (this->is_failed())
+    return false;
+  if (this->buffer_ != nullptr)
+    return true;
+  // this is dependent on the enum values.
+  RAMAllocator<uint16_t> allocator;
+  this->buffer_ = allocator.allocate(this->height_ * this->width_);
+  if (this->buffer_ == nullptr) {
+    this->mark_failed("Could not allocate buffer for display!");
+    return false;
+  }
+  return true;
+}
+
+void MipiRgb::draw_pixel_at(int x, int y, Color color) {
+  if (!this->get_clipping().inside(x, y) || this->is_failed())
+    return;
+
+  switch (this->rotation_) {
+    case display::DISPLAY_ROTATION_0_DEGREES:
+      break;
+    case display::DISPLAY_ROTATION_90_DEGREES:
+      std::swap(x, y);
+      x = this->width_ - x - 1;
+      break;
+    case display::DISPLAY_ROTATION_180_DEGREES:
+      x = this->width_ - x - 1;
+      y = this->height_ - y - 1;
+      break;
+    case display::DISPLAY_ROTATION_270_DEGREES:
+      std::swap(x, y);
+      y = this->height_ - y - 1;
+      break;
+  }
+  if (x >= this->get_width_internal() || x < 0 || y >= this->get_height_internal() || y < 0) {
+    return;
+  }
+  if (!this->check_buffer_())
+    return;
+  size_t pos = (y * this->width_) + x;
+  uint8_t hi_byte = static_cast<uint8_t>(color.r & 0xF8) | (color.g >> 5);
+  uint8_t lo_byte = static_cast<uint8_t>((color.g & 0x1C) << 3) | (color.b >> 3);
+  uint16_t new_color = hi_byte | (lo_byte << 8);  // big endian
+  if (this->buffer_[pos] == new_color)
+    return;
+  this->buffer_[pos] = new_color;
+  // low and high watermark may speed up drawing from buffer
+  if (x < this->x_low_)
+    this->x_low_ = x;
+  if (y < this->y_low_)
+    this->y_low_ = y;
+  if (x > this->x_high_)
+    this->x_high_ = x;
+  if (y > this->y_high_)
+    this->y_high_ = y;
+}
+void MipiRgb::fill(Color color) {
+  if (!this->check_buffer_())
+    return;
+  auto *ptr_16 = reinterpret_cast<uint16_t *>(this->buffer_);
+  uint8_t hi_byte = static_cast<uint8_t>(color.r & 0xF8) | (color.g >> 5);
+  uint8_t lo_byte = static_cast<uint8_t>((color.g & 0x1C) << 3) | (color.b >> 3);
+  uint16_t new_color = lo_byte | (hi_byte << 8);  // little endian
+  std::fill_n(ptr_16, this->width_ * this->height_, new_color);
+}
+
+int MipiRgb::get_width() {
+  switch (this->rotation_) {
+    case display::DISPLAY_ROTATION_90_DEGREES:
+    case display::DISPLAY_ROTATION_270_DEGREES:
+      return this->get_height_internal();
+    case display::DISPLAY_ROTATION_0_DEGREES:
+    case display::DISPLAY_ROTATION_180_DEGREES:
+    default:
+      return this->get_width_internal();
+  }
+}
+
+int MipiRgb::get_height() {
+  switch (this->rotation_) {
+    case display::DISPLAY_ROTATION_0_DEGREES:
+    case display::DISPLAY_ROTATION_180_DEGREES:
+      return this->get_height_internal();
+    case display::DISPLAY_ROTATION_90_DEGREES:
+    case display::DISPLAY_ROTATION_270_DEGREES:
+    default:
+      return this->get_width_internal();
+  }
+}
+
+static std::string get_pin_name(GPIOPin *pin) {
+  if (pin == nullptr)
+    return "None";
+  return pin->dump_summary();
+}
+
+void MipiRgb::dump_pins_(uint8_t start, uint8_t end, const char *name, uint8_t offset) {
+  for (uint8_t i = start; i != end; i++) {
+    ESP_LOGCONFIG(TAG, "  %s pin %d: %s", name, offset++, this->data_pins_[i]->dump_summary().c_str());
+  }
+}
+
+void MipiRgb::dump_config() {
+  ESP_LOGCONFIG(TAG,
+                "MIPI_RGB LCD"
+                "\n  Model: %s"
+                "\n  Width: %u"
+                "\n  Height: %u"
+                "\n  Rotation: %d degrees"
+                "\n  HSync Pulse Width: %u"
+                "\n  HSync Back Porch: %u"
+                "\n  HSync Front Porch: %u"
+                "\n  VSync Pulse Width: %u"
+                "\n  VSync Back Porch: %u"
+                "\n  VSync Front Porch: %u"
+                "\n  Invert Colors: %s"
+                "\n  Pixel Clock: %dMHz"
+                "\n  Reset Pin: %s"
+                "\n  DE Pin: %s"
+                "\n  PCLK Pin: %s"
+                "\n  HSYNC Pin: %s"
+                "\n  VSYNC Pin: %s",
+                this->model_, this->width_, this->height_, this->rotation_, this->hsync_pulse_width_,
+                this->hsync_back_porch_, this->hsync_front_porch_, this->vsync_pulse_width_, this->vsync_back_porch_,
+                this->vsync_front_porch_, YESNO(this->invert_colors_), this->pclk_frequency_ / 1000000,
+                get_pin_name(this->reset_pin_).c_str(), get_pin_name(this->de_pin_).c_str(),
+                get_pin_name(this->pclk_pin_).c_str(), get_pin_name(this->hsync_pin_).c_str(),
+                get_pin_name(this->vsync_pin_).c_str());
+
+  if (this->madctl_ & MADCTL_BGR) {
+    this->dump_pins_(8, 13, "Blue", 0);
+    this->dump_pins_(13, 16, "Green", 0);
+    this->dump_pins_(0, 3, "Green", 3);
+    this->dump_pins_(3, 8, "Red", 0);
+  } else {
+    this->dump_pins_(8, 13, "Red", 0);
+    this->dump_pins_(13, 16, "Green", 0);
+    this->dump_pins_(0, 3, "Green", 3);
+    this->dump_pins_(3, 8, "Blue", 0);
+  }
+}
+
+}  // namespace mipi_rgb
+}  // namespace esphome
+#endif  // USE_ESP32_VARIANT_ESP32S3