esphome 2025.7.4__py3-none-any.whl → 2025.8.0b1__py3-none-any.whl

esphome/components/mipi_dsi/display.py

@@ -0,0 +1,233 @@
+import importlib
+import logging
+import pkgutil
+
+from esphome import pins
+import esphome.codegen as cg
+from esphome.components import display
+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_COLOR_DEPTH,
+    CONF_HSYNC_BACK_PORCH,
+    CONF_HSYNC_FRONT_PORCH,
+    CONF_HSYNC_PULSE_WIDTH,
+    CONF_PCLK_FREQUENCY,
+    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_24BIT,
+    DriverChip,
+    dimension_schema,
+    get_color_depth,
+    map_sequence,
+    power_of_two,
+    requires_buffer,
+)
+import esphome.config_validation as cv
+from esphome.const import (
+    CONF_COLOR_ORDER,
+    CONF_DIMENSIONS,
+    CONF_ENABLE_PIN,
+    CONF_ID,
+    CONF_INIT_SEQUENCE,
+    CONF_INVERT_COLORS,
+    CONF_LAMBDA,
+    CONF_MIRROR_X,
+    CONF_MIRROR_Y,
+    CONF_MODEL,
+    CONF_RESET_PIN,
+    CONF_ROTATION,
+    CONF_SWAP_XY,
+    CONF_TRANSFORM,
+    CONF_WIDTH,
+)
+from esphome.final_validate import full_config
+
+from . import mipi_dsi_ns, models
+
+# Currently only ESP32-P4 is supported, so esp_ldo and psram are required
+DEPENDENCIES = ["esp32", "esp_ldo", "psram"]
+DOMAIN = "mipi_dsi"
+
+LOGGER = logging.getLogger(DOMAIN)
+
+MIPI_DSI = mipi_dsi_ns.class_("MIPI_DSI", display.Display, cg.Component)
+ColorOrder = display.display_ns.enum("ColorMode")
+ColorBitness = display.display_ns.enum("ColorBitness")
+
+CONF_LANE_BIT_RATE = "lane_bit_rate"
+CONF_LANES = "lanes"
+
+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()
+
+COLOR_DEPTHS = {
+    16: ColorBitness.COLOR_BITNESS_565,
+    24: ColorBitness.COLOR_BITNESS_888,
+}
+
+
+def model_schema(config):
+    model = MODELS[config[CONF_MODEL].upper()]
+    transform = cv.Schema(
+        {
+            cv.Required(CONF_MIRROR_X): cv.boolean,
+            cv.Required(CONF_MIRROR_Y): cv.boolean,
+        }
+    )
+    if model.get_default(CONF_SWAP_XY) != cv.UNDEFINED:
+        transform = transform.extend(
+            {
+                cv.Optional(CONF_SWAP_XY): cv.invalid(
+                    "Axis swapping not supported by this model"
+                )
+            }
+        )
+    else:
+        transform = transform.extend(
+            {
+                cv.Required(CONF_SWAP_XY): cv.boolean,
+            }
+        )
+    # CUSTOM model will need to provide a custom init sequence
+    iseqconf = (
+        cv.Required(CONF_INIT_SEQUENCE)
+        if model.initsequence is None
+        else cv.Optional(CONF_INIT_SEQUENCE)
+    )
+    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_24BIT, "16", "24")
+    schema = display.FULL_DISPLAY_SCHEMA.extend(
+        {
+            model.option(CONF_RESET_PIN, cv.UNDEFINED): pins.gpio_output_pin_schema,
+            cv.GenerateID(): cv.declare_id(MIPI_DSI),
+            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_COLOR_DEPTH, "16"): cv.one_of(
+                *[str(d) for d in COLOR_DEPTHS],
+                *[f"{d}bit" for d in COLOR_DEPTHS],
+                lower=True,
+            ),
+            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_LANES, 2): cv.int_range(1, 2),
+            model.option(CONF_LANE_BIT_RATE, None): cv.All(
+                cv.bps, cv.Range(min=100e6, max=3200e6)
+            ),
+            iseqconf: cv.ensure_list(map_sequence),
+            model.option(CONF_BYTE_ORDER, BYTE_ORDER_LITTLE): 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_,
+        }
+    )
+    return cv.All(
+        schema,
+        only_on_variant(supported=[const.VARIANT_ESP32P4]),
+        cv.only_with_esp_idf,
+    )
+
+
+def _config_schema(config):
+    config = cv.Schema(
+        {
+            cv.Required(CONF_MODEL): cv.one_of(*MODELS, upper=True),
+        },
+        extra=cv.ALLOW_EXTRA,
+    )(config)
+    return model_schema(config)(config)
+
+
+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
+    return config
+
+
+CONFIG_SCHEMA = _config_schema
+FINAL_VALIDATE_SCHEMA = _final_validate
+
+
+async def to_code(config):
+    model = MODELS[config[CONF_MODEL].upper()]
+    color_depth = COLOR_DEPTHS[get_color_depth(config)]
+    pixel_mode = int(config[CONF_PIXEL_MODE].removesuffix("bit"))
+    width, height, _offset_width, _offset_height = model.get_dimensions(config)
+    var = cg.new_Pvariable(config[CONF_ID], width, height, color_depth, pixel_mode)
+
+    sequence, madctl = model.get_sequence(config)
+    cg.add(var.set_model(config[CONF_MODEL]))
+    cg.add(var.set_init_sequence(sequence))
+    cg.add(var.set_madctl(madctl))
+    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_frequency(int(config[CONF_PCLK_FREQUENCY] / 1e6)))
+    cg.add(var.set_lanes(int(config[CONF_LANES])))
+    cg.add(var.set_lane_bit_rate(int(config[CONF_LANE_BIT_RATE] / 1e6)))
+    if reset_pin := config.get(CONF_RESET_PIN):
+        reset = await cg.gpio_pin_expression(reset_pin)
+        cg.add(var.set_reset_pin(reset))
+    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 model.rotation_as_transform(config):
+        config[CONF_ROTATION] = 0
+    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_dsi/mipi_dsi.cpp

@@ -0,0 +1,379 @@
+#ifdef USE_ESP32_VARIANT_ESP32P4
+#include <utility>
+#include "mipi_dsi.h"
+
+namespace esphome {
+namespace mipi_dsi {
+
+static bool notify_refresh_ready(esp_lcd_panel_handle_t panel, esp_lcd_dpi_panel_event_data_t *edata, void *user_ctx) {
+  auto *sem = static_cast<SemaphoreHandle_t *>(user_ctx);
+  BaseType_t need_yield = pdFALSE;
+  xSemaphoreGiveFromISR(sem, &need_yield);
+  return (need_yield == pdTRUE);
+}
+void MIPI_DSI::setup() {
+  ESP_LOGCONFIG(TAG, "Running Setup");
+
+  if (!this->enable_pins_.empty()) {
+    for (auto *pin : this->enable_pins_) {
+      pin->setup();
+      pin->digital_write(true);
+    }
+    delay(10);
+  }
+
+  esp_lcd_dsi_bus_config_t bus_config = {
+      .bus_id = 0,  // index from 0, specify the DSI host to use
+      .num_data_lanes =
+          this->lanes_,  // Number of data lanes to use, can't set a value that exceeds the chip's capability
+      .phy_clk_src = MIPI_DSI_PHY_CLK_SRC_DEFAULT,  // Clock source for the DPHY
+      .lane_bit_rate_mbps = this->lane_bit_rate_,   // Bit rate of the data lanes, in Mbps
+  };
+  auto err = esp_lcd_new_dsi_bus(&bus_config, &this->bus_handle_);
+  if (err != ESP_OK) {
+    this->smark_failed("lcd_new_dsi_bus failed", err);
+    return;
+  }
+  esp_lcd_dbi_io_config_t dbi_config = {
+      .virtual_channel = 0,
+      .lcd_cmd_bits = 8,    // according to the LCD spec
+      .lcd_param_bits = 8,  // according to the LCD spec
+  };
+  err = esp_lcd_new_panel_io_dbi(this->bus_handle_, &dbi_config, &this->io_handle_);
+  if (err != ESP_OK) {
+    this->smark_failed("new_panel_io_dbi failed", err);
+    return;
+  }
+  auto pixel_format = LCD_COLOR_PIXEL_FORMAT_RGB565;
+  if (this->color_depth_ == display::COLOR_BITNESS_888) {
+    pixel_format = LCD_COLOR_PIXEL_FORMAT_RGB888;
+  }
+  esp_lcd_dpi_panel_config_t dpi_config = {.virtual_channel = 0,
+                                           .dpi_clk_src = MIPI_DSI_DPI_CLK_SRC_DEFAULT,
+                                           .dpi_clock_freq_mhz = this->pclk_frequency_,
+                                           .pixel_format = pixel_format,
+                                           .num_fbs = 1,  // number of frame buffers to allocate
+                                           .video_timing =
+                                               {
+                                                   .h_size = this->width_,
+                                                   .v_size = this->height_,
+                                                   .hsync_pulse_width = this->hsync_pulse_width_,
+                                                   .hsync_back_porch = this->hsync_back_porch_,
+                                                   .hsync_front_porch = this->hsync_front_porch_,
+                                                   .vsync_pulse_width = this->vsync_pulse_width_,
+                                                   .vsync_back_porch = this->vsync_back_porch_,
+                                                   .vsync_front_porch = this->vsync_front_porch_,
+                                               },
+                                           .flags = {
+                                               .use_dma2d = true,
+                                           }};
+  err = esp_lcd_new_panel_dpi(this->bus_handle_, &dpi_config, &this->handle_);
+  if (err != ESP_OK) {
+    this->smark_failed("esp_lcd_new_panel_dpi failed", err);
+    return;
+  }
+  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);
+  } else {
+    esp_lcd_panel_io_tx_param(this->io_handle_, SW_RESET_CMD, nullptr, 0);
+  }
+  // need to know when the display is ready for SLPOUT command - will be 120ms after reset
+  auto when = millis() + 120;
+  err = esp_lcd_panel_init(this->handle_);
+  if (err != ESP_OK) {
+    this->smark_failed("esp_lcd_init failed", err);
+    return;
+  }
+  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) {
+        // are we ready, boots?
+        int duration = when - millis();
+        if (duration > 0) {
+          delay(duration);
+        }
+      }
+      const auto *ptr = vec.data() + index;
+      ESP_LOGVV(TAG, "Command %02X, length %d, byte(s) %s", cmd, num_args,
+                format_hex_pretty(ptr, num_args, '.', false).c_str());
+      err = esp_lcd_panel_io_tx_param(this->io_handle_, cmd, ptr, num_args);
+      if (err != ESP_OK) {
+        this->smark_failed("lcd_panel_io_tx_param failed", err);
+        return;
+      }
+      index += num_args;
+      if (cmd == SLEEP_OUT)
+        delay(10);
+    }
+  }
+  this->io_lock_ = xSemaphoreCreateBinary();
+  esp_lcd_dpi_panel_event_callbacks_t cbs = {
+      .on_color_trans_done = notify_refresh_ready,
+  };
+
+  err = (esp_lcd_dpi_panel_register_event_callbacks(this->handle_, &cbs, this->io_lock_));
+  if (err != ESP_OK) {
+    this->smark_failed("Failed to register callbacks", err);
+    return;
+  }
+
+  ESP_LOGCONFIG(TAG, "MIPI DSI setup complete");
+}
+
+void MIPI_DSI::update() {
+  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, 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 MIPI_DSI::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)
+    return;
+  // if color mapping is required, pass the buck.
+  // note that endianness is not considered here - it is assumed to match!
+  if (bitness != this->color_depth_) {
+    display::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, ptr, x_offset, y_offset, x_pad);
+}
+
+void MIPI_DSI::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 bytes_per_pixel = 3 - this->color_depth_;
+  auto stride = (x_offset + w + x_pad) * bytes_per_pixel;
+  ptr += y_offset * stride + x_offset * bytes_per_pixel;  // 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);
+    xSemaphoreTake(this->io_lock_, portMAX_DELAY);
+
+  } 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
+      xSemaphoreTake(this->io_lock_, portMAX_DELAY);
+    }
+  }
+  if (err != ESP_OK)
+    ESP_LOGE(TAG, "lcd_lcd_panel_draw_bitmap failed: %s", esp_err_to_name(err));
+}
+
+bool MIPI_DSI::check_buffer_() {
+  if (this->is_failed())
+    return false;
+  if (this->buffer_ != nullptr)
+    return true;
+  // this is dependent on the enum values.
+  auto bytes_per_pixel = 3 - this->color_depth_;
+  RAMAllocator<uint8_t> allocator;
+  this->buffer_ = allocator.allocate(this->height_ * this->width_ * bytes_per_pixel);
+  if (this->buffer_ == nullptr) {
+    this->mark_failed("Could not allocate buffer for display!");
+    return false;
+  }
+  return true;
+}
+
+void MIPI_DSI::draw_pixel_at(int x, int y, Color color) {
+  if (!this->get_clipping().inside(x, y))
+    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;
+  }
+  auto pixel = convert_big_endian(display::ColorUtil::color_to_565(color));
+  if (!this->check_buffer_())
+    return;
+  size_t pos = (y * this->width_) + x;
+  switch (this->color_depth_) {
+    case display::COLOR_BITNESS_565: {
+      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
+      if (ptr_16[pos] == new_color)
+        return;
+      ptr_16[pos] = new_color;
+      break;
+    }
+    case display::COLOR_BITNESS_888:
+      if (this->color_mode_ == display::COLOR_ORDER_BGR) {
+        this->buffer_[pos * 3] = color.b;
+        this->buffer_[pos * 3 + 1] = color.g;
+        this->buffer_[pos * 3 + 2] = color.r;
+      } else {
+        this->buffer_[pos * 3] = color.r;
+        this->buffer_[pos * 3 + 1] = color.g;
+        this->buffer_[pos * 3 + 2] = color.b;
+      }
+      break;
+    case display::COLOR_BITNESS_332:
+      break;
+  }
+  // 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 MIPI_DSI::fill(Color color) {
+  if (!this->check_buffer_())
+    return;
+  switch (this->color_depth_) {
+    case display::COLOR_BITNESS_565: {
+      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);
+      break;
+    }
+
+    case display::COLOR_BITNESS_888:
+      if (this->color_mode_ == display::COLOR_ORDER_BGR) {
+        for (size_t i = 0; i != this->width_ * this->height_; i++) {
+          this->buffer_[i * 3 + 0] = color.b;
+          this->buffer_[i * 3 + 1] = color.g;
+          this->buffer_[i * 3 + 2] = color.r;
+        }
+      } else {
+        for (size_t i = 0; i != this->width_ * this->height_; i++) {
+          this->buffer_[i * 3 + 0] = color.r;
+          this->buffer_[i * 3 + 1] = color.g;
+          this->buffer_[i * 3 + 2] = color.b;
+        }
+      }
+
+    default:
+      break;
+  }
+}
+
+int MIPI_DSI::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 MIPI_DSI::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 const uint8_t PIXEL_MODES[] = {0, 16, 18, 24};
+
+void MIPI_DSI::dump_config() {
+  ESP_LOGCONFIG(TAG,
+                "MIPI_DSI RGB LCD"
+                "\n  Model: %s"
+                "\n  Width: %u"
+                "\n  Height: %u"
+                "\n  Mirror X: %s"
+                "\n  Mirror Y: %s"
+                "\n  Swap X/Y: %s"
+                "\n  Rotation: %d degrees"
+                "\n  DSI Lanes: %u"
+                "\n  Lane Bit Rate: %uMbps"
+                "\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  Buffer Color Depth: %d bit"
+                "\n  Display Pixel Mode: %d bit"
+                "\n  Color Order: %s"
+                "\n  Invert Colors: %s"
+                "\n  Pixel Clock: %dMHz",
+                this->model_, this->width_, this->height_, YESNO(this->madctl_ & (MADCTL_XFLIP | MADCTL_MX)),
+                YESNO(this->madctl_ & (MADCTL_YFLIP | MADCTL_MY)), YESNO(this->madctl_ & MADCTL_MV), this->rotation_,
+                this->lanes_, this->lane_bit_rate_, this->hsync_pulse_width_, this->hsync_back_porch_,
+                this->hsync_front_porch_, this->vsync_pulse_width_, this->vsync_back_porch_, this->vsync_front_porch_,
+                (3 - this->color_depth_) * 8, this->pixel_mode_, this->madctl_ & MADCTL_BGR ? "BGR" : "RGB",
+                YESNO(this->invert_colors_), this->pclk_frequency_);
+  LOG_PIN("  Reset Pin ", this->reset_pin_);
+}
+}  // namespace mipi_dsi
+}  // namespace esphome
+#endif  // USE_ESP32_VARIANT_ESP32P4