esphome 2025.4.2__py3-none-any.whl → 2025.5.0__py3-none-any.whl

esphome/components/mipi_spi/mipi_spi.cpp

@@ -0,0 +1,481 @@
+#include "mipi_spi.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace mipi_spi {
+
+void MipiSpi::setup() {
+  ESP_LOGCONFIG(TAG, "Setting up MIPI SPI");
+  this->spi_setup();
+  if (this->dc_pin_ != nullptr) {
+    this->dc_pin_->setup();
+    this->dc_pin_->digital_write(false);
+  }
+  for (auto *pin : this->enable_pins_) {
+    pin->setup();
+    pin->digital_write(true);
+  }
+  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);
+  }
+  this->bus_width_ = this->parent_->get_bus_width();
+
+  // need to know when the display is ready for SLPOUT command - will be 120ms after reset
+  auto when = millis() + 120;
+  delay(10);
+  size_t index = 0;
+  auto &vec = this->init_sequence_;
+  while (index != vec.size()) {
+    if (vec.size() - index < 2) {
+      ESP_LOGE(TAG, "Malformed init sequence");
+      this->mark_failed();
+      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) {
+        ESP_LOGE(TAG, "Malformed init sequence");
+        this->mark_failed();
+        return;
+      }
+      auto arg_byte = vec[index];
+      switch (cmd) {
+        case SLEEP_OUT: {
+          // are we ready, boots?
+          int duration = when - millis();
+          if (duration > 0) {
+            ESP_LOGD(TAG, "Sleep %dms", duration);
+            delay(duration);
+          }
+        } break;
+
+        case INVERT_ON:
+          this->invert_colors_ = true;
+          break;
+        case MADCTL_CMD:
+          this->madctl_ = arg_byte;
+          break;
+        case PIXFMT:
+          this->pixel_mode_ = arg_byte & 0x11 ? PIXEL_MODE_16 : PIXEL_MODE_18;
+          break;
+        case BRIGHTNESS:
+          this->brightness_ = arg_byte;
+          break;
+
+        default:
+          break;
+      }
+      const auto *ptr = vec.data() + index;
+      ESP_LOGD(TAG, "Command %02X, length %d, byte %02X", cmd, num_args, arg_byte);
+      this->write_command_(cmd, ptr, num_args);
+      index += num_args;
+      if (cmd == SLEEP_OUT)
+        delay(10);
+    }
+  }
+  this->setup_complete_ = true;
+  if (this->draw_from_origin_)
+    check_buffer_();
+  ESP_LOGCONFIG(TAG, "MIPI SPI setup complete");
+}
+
+void MipiSpi::update() {
+  if (!this->setup_complete_ || this->is_failed()) {
+    return;
+  }
+  this->do_update_();
+  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_);
+  // Some chips require that the drawing window be aligned on certain boundaries
+  auto dr = this->draw_rounding_;
+  this->x_low_ = this->x_low_ / dr * dr;
+  this->y_low_ = this->y_low_ / dr * dr;
+  this->x_high_ = (this->x_high_ + dr) / dr * dr - 1;
+  this->y_high_ = (this->y_high_ + dr) / dr * dr - 1;
+  if (this->draw_from_origin_) {
+    this->x_low_ = 0;
+    this->y_low_ = 0;
+    this->x_high_ = this->width_ - 1;
+  }
+  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 MipiSpi::fill(Color color) {
+  if (!this->check_buffer_())
+    return;
+  this->x_low_ = 0;
+  this->y_low_ = 0;
+  this->x_high_ = this->get_width_internal() - 1;
+  this->y_high_ = this->get_height_internal() - 1;
+  switch (this->color_depth_) {
+    case display::COLOR_BITNESS_332: {
+      auto new_color = display::ColorUtil::color_to_332(color, display::ColorOrder::COLOR_ORDER_RGB);
+      memset(this->buffer_, (uint8_t) new_color, this->buffer_bytes_);
+      break;
+    }
+    default: {
+      auto new_color = display::ColorUtil::color_to_565(color);
+      if (((uint8_t) (new_color >> 8)) == ((uint8_t) new_color)) {
+        // Upper and lower is equal can use quicker memset operation. Takes ~20ms.
+        memset(this->buffer_, (uint8_t) new_color, this->buffer_bytes_);
+      } else {
+        auto *ptr_16 = reinterpret_cast<uint16_t *>(this->buffer_);
+        auto len = this->buffer_bytes_ / 2;
+        while (len--) {
+          *ptr_16++ = new_color;
+        }
+      }
+    }
+  }
+}
+
+void MipiSpi::draw_absolute_pixel_internal(int x, int y, Color color) {
+  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;
+  switch (this->color_depth_) {
+    case display::COLOR_BITNESS_332: {
+      uint8_t new_color = display::ColorUtil::color_to_332(color);
+      if (this->buffer_[pos] == new_color)
+        return;
+      this->buffer_[pos] = new_color;
+      break;
+    }
+
+    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 = hi_byte | (lo_byte << 8);  // big endian
+      if (ptr_16[pos] == new_color)
+        return;
+      ptr_16[pos] = new_color;
+      break;
+    }
+    default:
+      return;
+  }
+  // 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 MipiSpi::reset_params_() {
+  if (!this->is_ready())
+    return;
+  this->write_command_(this->invert_colors_ ? INVERT_ON : INVERT_OFF);
+  if (this->brightness_.has_value())
+    this->write_command_(BRIGHTNESS, this->brightness_.value());
+}
+
+void MipiSpi::write_init_sequence_() {
+  size_t index = 0;
+  auto &vec = this->init_sequence_;
+  while (index != vec.size()) {
+    if (vec.size() - index < 2) {
+      ESP_LOGE(TAG, "Malformed init sequence");
+      this->mark_failed();
+      return;
+    }
+    uint8_t cmd = vec[index++];
+    uint8_t x = vec[index++];
+    if (x == DELAY_FLAG) {
+      ESP_LOGV(TAG, "Delay %dms", cmd);
+      delay(cmd);
+    } else {
+      uint8_t num_args = x & 0x7F;
+      if (vec.size() - index < num_args) {
+        ESP_LOGE(TAG, "Malformed init sequence");
+        this->mark_failed();
+        return;
+      }
+      const auto *ptr = vec.data() + index;
+      this->write_command_(cmd, ptr, num_args);
+      index += num_args;
+    }
+  }
+  this->setup_complete_ = true;
+  ESP_LOGCONFIG(TAG, "MIPI SPI setup complete");
+}
+
+void MipiSpi::set_addr_window_(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2) {
+  ESP_LOGVV(TAG, "Set addr %d/%d, %d/%d", x1, y1, x2, y2);
+  uint8_t buf[4];
+  x1 += this->offset_width_;
+  x2 += this->offset_width_;
+  y1 += this->offset_height_;
+  y2 += this->offset_height_;
+  put16_be(buf, y1);
+  put16_be(buf + 2, y2);
+  this->write_command_(RASET, buf, sizeof buf);
+  put16_be(buf, x1);
+  put16_be(buf + 2, x2);
+  this->write_command_(CASET, buf, sizeof buf);
+}
+
+void MipiSpi::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 (!this->setup_complete_ || this->is_failed())
+    return;
+  if (w <= 0 || h <= 0)
+    return;
+  if (bitness != this->color_depth_ || big_endian != (this->bit_order_ == spi::BIT_ORDER_MSB_FIRST)) {
+    Display::draw_pixels_at(x_start, y_start, w, h, ptr, order, bitness, big_endian, x_offset, y_offset, x_pad);
+    return;
+  }
+  if (this->draw_from_origin_) {
+    auto stride = x_offset + w + x_pad;
+    for (int y = 0; y != h; y++) {
+      memcpy(this->buffer_ + ((y + y_start) * this->width_ + x_start) * 2,
+             ptr + ((y + y_offset) * stride + x_offset) * 2, w * 2);
+    }
+    ptr = this->buffer_;
+    w = this->width_;
+    h += y_start;
+    x_start = 0;
+    y_start = 0;
+    x_offset = 0;
+    y_offset = 0;
+  }
+  this->write_to_display_(x_start, y_start, w, h, ptr, x_offset, y_offset, x_pad);
+}
+
+void MipiSpi::write_18_from_16_bit_(const uint16_t *ptr, size_t w, size_t h, size_t stride) {
+  stride -= w;
+  uint8_t transfer_buffer[6 * 256];
+  size_t idx = 0;  // index into transfer_buffer
+  while (h-- != 0) {
+    for (auto x = w; x-- != 0;) {
+      auto color_val = *ptr++;
+      // deal with byte swapping
+      transfer_buffer[idx++] = (color_val & 0xF8);                                       // Blue
+      transfer_buffer[idx++] = ((color_val & 0x7) << 5) | ((color_val & 0xE000) >> 11);  // Green
+      transfer_buffer[idx++] = (color_val >> 5) & 0xF8;                                  // Red
+      if (idx == sizeof(transfer_buffer)) {
+        this->write_array(transfer_buffer, idx);
+        idx = 0;
+      }
+    }
+    ptr += stride;
+  }
+  if (idx != 0)
+    this->write_array(transfer_buffer, idx);
+}
+
+void MipiSpi::write_18_from_8_bit_(const uint8_t *ptr, size_t w, size_t h, size_t stride) {
+  stride -= w;
+  uint8_t transfer_buffer[6 * 256];
+  size_t idx = 0;  // index into transfer_buffer
+  while (h-- != 0) {
+    for (auto x = w; x-- != 0;) {
+      auto color_val = *ptr++;
+      transfer_buffer[idx++] = color_val & 0xE0;         // Red
+      transfer_buffer[idx++] = (color_val << 3) & 0xE0;  // Green
+      transfer_buffer[idx++] = color_val << 6;           // Blue
+      if (idx == sizeof(transfer_buffer)) {
+        this->write_array(transfer_buffer, idx);
+        idx = 0;
+      }
+    }
+    ptr += stride;
+  }
+  if (idx != 0)
+    this->write_array(transfer_buffer, idx);
+}
+
+void MipiSpi::write_16_from_8_bit_(const uint8_t *ptr, size_t w, size_t h, size_t stride) {
+  stride -= w;
+  uint8_t transfer_buffer[6 * 256];
+  size_t idx = 0;  // index into transfer_buffer
+  while (h-- != 0) {
+    for (auto x = w; x-- != 0;) {
+      auto color_val = *ptr++;
+      transfer_buffer[idx++] = (color_val & 0xE0) | ((color_val & 0x1C) >> 2);
+      transfer_buffer[idx++] = (color_val & 0x3) << 3;
+      if (idx == sizeof(transfer_buffer)) {
+        this->write_array(transfer_buffer, idx);
+        idx = 0;
+      }
+    }
+    ptr += stride;
+  }
+  if (idx != 0)
+    this->write_array(transfer_buffer, idx);
+}
+
+void MipiSpi::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) {
+  this->set_addr_window_(x_start, y_start, x_start + w - 1, y_start + h - 1);
+  auto stride = x_offset + w + x_pad;
+  const auto *offset_ptr = ptr;
+  if (this->color_depth_ == display::COLOR_BITNESS_332) {
+    offset_ptr += y_offset * stride + x_offset;
+  } else {
+    stride *= 2;
+    offset_ptr += y_offset * stride + x_offset * 2;
+  }
+
+  switch (this->bus_width_) {
+    case 4:
+      this->enable();
+      if (x_offset == 0 && x_pad == 0 && y_offset == 0) {
+        // we could deal here with a non-zero y_offset, but if x_offset is zero, y_offset probably will be so don't
+        // bother
+        this->write_cmd_addr_data(8, 0x32, 24, WDATA << 8, ptr, w * h * 2, 4);
+      } else {
+        this->write_cmd_addr_data(8, 0x32, 24, WDATA << 8, nullptr, 0, 4);
+        for (int y = 0; y != h; y++) {
+          this->write_cmd_addr_data(0, 0, 0, 0, offset_ptr, w * 2, 4);
+          offset_ptr += stride;
+        }
+      }
+      break;
+
+    case 8:
+      this->write_command_(WDATA);
+      this->enable();
+      if (x_offset == 0 && x_pad == 0 && y_offset == 0) {
+        this->write_cmd_addr_data(0, 0, 0, 0, ptr, w * h * 2, 8);
+      } else {
+        for (int y = 0; y != h; y++) {
+          this->write_cmd_addr_data(0, 0, 0, 0, offset_ptr, w * 2, 8);
+          offset_ptr += stride;
+        }
+      }
+      break;
+
+    default:
+      this->write_command_(WDATA);
+      this->enable();
+
+      if (this->color_depth_ == display::COLOR_BITNESS_565) {
+        // Source buffer is 16-bit RGB565
+        if (this->pixel_mode_ == PIXEL_MODE_18) {
+          // Convert RGB565 to RGB666
+          this->write_18_from_16_bit_(reinterpret_cast<const uint16_t *>(offset_ptr), w, h, stride / 2);
+        } else {
+          // Direct RGB565 output
+          if (x_offset == 0 && x_pad == 0 && y_offset == 0) {
+            this->write_array(ptr, w * h * 2);
+          } else {
+            for (int y = 0; y != h; y++) {
+              this->write_array(offset_ptr, w * 2);
+              offset_ptr += stride;
+            }
+          }
+        }
+      } else {
+        // Source buffer is 8-bit RGB332
+        if (this->pixel_mode_ == PIXEL_MODE_18) {
+          // Convert RGB332 to RGB666
+          this->write_18_from_8_bit_(offset_ptr, w, h, stride);
+        } else {
+          this->write_16_from_8_bit_(offset_ptr, w, h, stride);
+        }
+        break;
+      }
+  }
+  this->disable();
+}
+
+void MipiSpi::write_command_(uint8_t cmd, const uint8_t *bytes, size_t len) {
+  ESP_LOGV(TAG, "Command %02X, length %d, bytes %s", cmd, len, format_hex_pretty(bytes, len).c_str());
+  if (this->bus_width_ == 4) {
+    this->enable();
+    this->write_cmd_addr_data(8, 0x02, 24, cmd << 8, bytes, len);
+    this->disable();
+  } else if (this->bus_width_ == 8) {
+    this->dc_pin_->digital_write(false);
+    this->enable();
+    this->write_cmd_addr_data(0, 0, 0, 0, &cmd, 1, 8);
+    this->disable();
+    this->dc_pin_->digital_write(true);
+    if (len != 0) {
+      this->enable();
+      this->write_cmd_addr_data(0, 0, 0, 0, bytes, len, 8);
+      this->disable();
+    }
+  } else {
+    this->dc_pin_->digital_write(false);
+    this->enable();
+    this->write_byte(cmd);
+    this->disable();
+    this->dc_pin_->digital_write(true);
+    if (len != 0) {
+      if (this->spi_16_) {
+        for (size_t i = 0; i != len; i++) {
+          this->enable();
+          this->write_byte(0);
+          this->write_byte(bytes[i]);
+          this->disable();
+        }
+      } else {
+        this->enable();
+        this->write_array(bytes, len);
+        this->disable();
+      }
+    }
+  }
+}
+
+void MipiSpi::dump_config() {
+  ESP_LOGCONFIG(TAG, "MIPI_SPI Display");
+  ESP_LOGCONFIG(TAG, "  Model: %s", this->model_);
+  ESP_LOGCONFIG(TAG, "  Width: %u", this->width_);
+  ESP_LOGCONFIG(TAG, "  Height: %u", this->height_);
+  if (this->offset_width_ != 0)
+    ESP_LOGCONFIG(TAG, "  Offset width: %u", this->offset_width_);
+  if (this->offset_height_ != 0)
+    ESP_LOGCONFIG(TAG, "  Offset height: %u", this->offset_height_);
+  ESP_LOGCONFIG(TAG, "  Swap X/Y: %s", YESNO(this->madctl_ & MADCTL_MV));
+  ESP_LOGCONFIG(TAG, "  Mirror X: %s", YESNO(this->madctl_ & (MADCTL_MX | MADCTL_XFLIP)));
+  ESP_LOGCONFIG(TAG, "  Mirror Y: %s", YESNO(this->madctl_ & (MADCTL_MY | MADCTL_YFLIP)));
+  ESP_LOGCONFIG(TAG, "  Color depth: %d bits", this->color_depth_ == display::COLOR_BITNESS_565 ? 16 : 8);
+  ESP_LOGCONFIG(TAG, "  Invert colors: %s", YESNO(this->invert_colors_));
+  ESP_LOGCONFIG(TAG, "  Color order: %s", this->madctl_ & MADCTL_BGR ? "BGR" : "RGB");
+  ESP_LOGCONFIG(TAG, "  Pixel mode: %s", this->pixel_mode_ == PIXEL_MODE_18 ? "18bit" : "16bit");
+  if (this->brightness_.has_value())
+    ESP_LOGCONFIG(TAG, "  Brightness: %u", this->brightness_.value());
+  if (this->spi_16_)
+    ESP_LOGCONFIG(TAG, "  SPI 16bit: YES");
+  ESP_LOGCONFIG(TAG, "  Draw rounding: %u", this->draw_rounding_);
+  if (this->draw_from_origin_)
+    ESP_LOGCONFIG(TAG, "  Draw from origin: YES");
+  LOG_PIN("  CS Pin: ", this->cs_);
+  LOG_PIN("  Reset Pin: ", this->reset_pin_);
+  LOG_PIN("  DC Pin: ", this->dc_pin_);
+  ESP_LOGCONFIG(TAG, "  SPI Mode: %d", this->mode_);
+  ESP_LOGCONFIG(TAG, "  SPI Data rate: %dMHz", static_cast<unsigned>(this->data_rate_ / 1000000));
+  ESP_LOGCONFIG(TAG, "  SPI Bus width: %d", this->bus_width_);
+}
+
+}  // namespace mipi_spi
+}  // namespace esphome

esphome/components/mipi_spi/mipi_spi.h

@@ -0,0 +1,171 @@
+#pragma once
+
+#include <utility>
+
+#include "esphome/components/spi/spi.h"
+#include "esphome/components/display/display.h"
+#include "esphome/components/display/display_buffer.h"
+#include "esphome/components/display/display_color_utils.h"
+
+namespace esphome {
+namespace mipi_spi {
+
+constexpr static const char *const TAG = "display.mipi_spi";
+static const uint8_t SW_RESET_CMD = 0x01;
+static const uint8_t SLEEP_OUT = 0x11;
+static const uint8_t NORON = 0x13;
+static const uint8_t INVERT_OFF = 0x20;
+static const uint8_t INVERT_ON = 0x21;
+static const uint8_t ALL_ON = 0x23;
+static const uint8_t WRAM = 0x24;
+static const uint8_t MIPI = 0x26;
+static const uint8_t DISPLAY_ON = 0x29;
+static const uint8_t RASET = 0x2B;
+static const uint8_t CASET = 0x2A;
+static const uint8_t WDATA = 0x2C;
+static const uint8_t TEON = 0x35;
+static const uint8_t MADCTL_CMD = 0x36;
+static const uint8_t PIXFMT = 0x3A;
+static const uint8_t BRIGHTNESS = 0x51;
+static const uint8_t SWIRE1 = 0x5A;
+static const uint8_t SWIRE2 = 0x5B;
+static const uint8_t PAGESEL = 0xFE;
+
+static const uint8_t MADCTL_MY = 0x80;     // Bit 7 Bottom to top
+static const uint8_t MADCTL_MX = 0x40;     // Bit 6 Right to left
+static const uint8_t MADCTL_MV = 0x20;     // Bit 5 Swap axes
+static const uint8_t MADCTL_RGB = 0x00;    // Bit 3 Red-Green-Blue pixel order
+static const uint8_t MADCTL_BGR = 0x08;    // Bit 3 Blue-Green-Red pixel order
+static const uint8_t MADCTL_XFLIP = 0x02;  // Mirror the display horizontally
+static const uint8_t MADCTL_YFLIP = 0x01;  // Mirror the display vertically
+
+static const uint8_t DELAY_FLAG = 0xFF;
+// store a 16 bit value in a buffer, big endian.
+static inline void put16_be(uint8_t *buf, uint16_t value) {
+  buf[0] = value >> 8;
+  buf[1] = value;
+}
+
+enum PixelMode {
+  PIXEL_MODE_16,
+  PIXEL_MODE_18,
+};
+
+class MipiSpi : public display::DisplayBuffer,
+                public spi::SPIDevice<spi::BIT_ORDER_MSB_FIRST, spi::CLOCK_POLARITY_LOW, spi::CLOCK_PHASE_LEADING,
+                                      spi::DATA_RATE_1MHZ> {
+ public:
+  MipiSpi(size_t width, size_t height, int16_t offset_width, int16_t offset_height, display::ColorBitness color_depth)
+      : width_(width),
+        height_(height),
+        offset_width_(offset_width),
+        offset_height_(offset_height),
+        color_depth_(color_depth) {}
+  void set_model(const char *model) { this->model_ = model; }
+  void update() override;
+  void setup() override;
+  display::ColorOrder get_color_mode() {
+    return this->madctl_ & MADCTL_BGR ? display::COLOR_ORDER_BGR : display::COLOR_ORDER_RGB;
+  }
+
+  void set_reset_pin(GPIOPin *reset_pin) { this->reset_pin_ = reset_pin; }
+  void set_enable_pins(std::vector<GPIOPin *> enable_pins) { this->enable_pins_ = std::move(enable_pins); }
+  void set_dc_pin(GPIOPin *dc_pin) { this->dc_pin_ = dc_pin; }
+  void set_invert_colors(bool invert_colors) {
+    this->invert_colors_ = invert_colors;
+    this->reset_params_();
+  }
+  void set_brightness(uint8_t brightness) {
+    this->brightness_ = brightness;
+    this->reset_params_();
+  }
+
+  void set_draw_from_origin(bool draw_from_origin) { this->draw_from_origin_ = draw_from_origin; }
+  display::DisplayType get_display_type() override { return display::DisplayType::DISPLAY_TYPE_COLOR; }
+  void dump_config() override;
+
+  int get_width_internal() override { return this->width_; }
+  int get_height_internal() override { return this->height_; }
+  bool can_proceed() override { return this->setup_complete_; }
+  void set_init_sequence(const std::vector<uint8_t> &sequence) { this->init_sequence_ = sequence; }
+  void set_draw_rounding(unsigned rounding) { this->draw_rounding_ = rounding; }
+  void set_spi_16(bool spi_16) { this->spi_16_ = spi_16; }
+
+ protected:
+  bool check_buffer_() {
+    if (this->is_failed())
+      return false;
+    if (this->buffer_ != nullptr)
+      return true;
+    auto bytes_per_pixel = this->color_depth_ == display::COLOR_BITNESS_565 ? 2 : 1;
+    this->init_internal_(this->width_ * this->height_ * bytes_per_pixel);
+    if (this->buffer_ == nullptr) {
+      this->mark_failed();
+      return false;
+    }
+    this->buffer_bytes_ = this->width_ * this->height_ * bytes_per_pixel;
+    return true;
+  }
+  void fill(Color color) override;
+  void draw_absolute_pixel_internal(int x, int y, Color color) override;
+  void 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) override;
+  void write_18_from_16_bit_(const uint16_t *ptr, size_t w, size_t h, size_t stride);
+  void write_18_from_8_bit_(const uint8_t *ptr, size_t w, size_t h, size_t stride);
+  void write_16_from_8_bit_(const uint8_t *ptr, size_t w, size_t h, size_t stride);
+  void 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);
+  /**
+   * the RM67162 in quad SPI mode seems to work like this (not in the datasheet, this is deduced from the
+   * sample code.)
+   *
+   * Immediately after enabling /CS send 4 bytes in single-dataline SPI mode:
+   *    0: either 0x2 or 0x32. The first indicates that any subsequent data bytes after the initial 4 will be
+   *        sent in 1-dataline SPI. The second indicates quad mode.
+   *    1: 0x00
+   *    2: The command (register address) byte.
+   *    3: 0x00
+   *
+   *    This is followed by zero or more data bytes in either 1-wire or 4-wire mode, depending on the first byte.
+   *    At the conclusion of the write, de-assert /CS.
+   *
+   * @param cmd
+   * @param bytes
+   * @param len
+   */
+  void write_command_(uint8_t cmd, const uint8_t *bytes, size_t len);
+
+  void write_command_(uint8_t cmd, uint8_t data) { this->write_command_(cmd, &data, 1); }
+  void write_command_(uint8_t cmd) { this->write_command_(cmd, &cmd, 0); }
+  void reset_params_();
+  void write_init_sequence_();
+  void set_addr_window_(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2);
+
+  GPIOPin *reset_pin_{nullptr};
+  std::vector<GPIOPin *> enable_pins_{};
+  GPIOPin *dc_pin_{nullptr};
+  uint16_t x_low_{1};
+  uint16_t y_low_{1};
+  uint16_t x_high_{0};
+  uint16_t y_high_{0};
+  bool setup_complete_{};
+
+  bool invert_colors_{};
+  size_t width_;
+  size_t height_;
+  int16_t offset_width_;
+  int16_t offset_height_;
+  size_t buffer_bytes_{0};
+  display::ColorBitness color_depth_;
+  PixelMode pixel_mode_{PIXEL_MODE_16};
+  uint8_t bus_width_{};
+  bool spi_16_{};
+  uint8_t madctl_{};
+  bool draw_from_origin_{false};
+  unsigned draw_rounding_{2};
+  optional<uint8_t> brightness_{};
+  const char *model_{"Unknown"};
+  std::vector<uint8_t> init_sequence_{};
+};
+}  // namespace mipi_spi
+}  // namespace esphome