Move to lovyangfx develop for Native

arch/portduino/portduino.ini

@@ -24,7 +24,7 @@ lib_deps =
   ${env.lib_deps}
   ${networking_base.lib_deps}
   rweather/Crypto@^0.4.0
-  lovyan03/LovyanGFX@^1.1.12
+  https://github.com/lovyan03/LovyanGFX.git#d35e60f269dfecbb18a8cb0fd07d594c2fb7e7a8
 
 build_flags =
   ${arduino_base.build_flags}
@@ -34,4 +34,4 @@ build_flags =
   -DPORTDUINO_LINUX_HARDWARE
   -lbluetooth
   -lgpiod
-  -lyaml-cpp
+  -lyaml-cpp

src/graphics/TFTDisplay.cpp

@@ -1,7 +1,6 @@
 #include "configuration.h"
 #include "main.h"
 #if ARCH_PORTDUINO
-#include "mesh_bus_spi.h"
 #include "platform/portduino/PortduinoGlue.h"
 #endif
 
@@ -340,7 +339,7 @@ static TFT_eSPI *tft = nullptr; // Invoke library, pins defined in User_Setup.h
 class LGFX : public lgfx::LGFX_Device
 {
     lgfx::Panel_LCD *_panel_instance;
-    lgfx::Mesh_Bus_SPI _bus_instance;
+    lgfx::Bus_SPI _bus_instance;
 
     lgfx::ITouch *_touch_instance;
 
@@ -357,7 +356,7 @@ class LGFX : public lgfx::LGFX_Device
             _panel_instance = new lgfx::Panel_ILI9341;
         auto buscfg = _bus_instance.config();
         buscfg.spi_mode = 0;
-        _bus_instance.spi_device(DisplaySPI, settingsStrings[displayspidev]);
+        _bus_instance.spi_device(DisplaySPI);
 
         buscfg.pin_dc = settingsMap[displayDC]; // Set SPI DC pin number (-1 = disable)
 

src/graphics/mesh_bus_spi.cpp

@@ -1,188 +0,0 @@
-// This code has been copied from LovyanGFX to make the SPI device selectable for touchscreens.
-// Ideally this could eventually be an inherited class from BUS_SPI,
-// but currently too many internal objects are set private.
-
-#include "configuration.h"
-#if ARCH_PORTDUINO
-#include "lgfx/v1/misc/pixelcopy.hpp"
-#include "main.h"
-#include "mesh_bus_spi.h"
-#include <Arduino.h>
-#include <SPI.h>
-
-namespace lgfx
-{
-inline namespace v1
-{
-//----------------------------------------------------------------------------
-
-void Mesh_Bus_SPI::config(const config_t &config)
-{
-    _cfg = config;
-
-    if (_cfg.pin_dc >= 0) {
-        pinMode(_cfg.pin_dc, pin_mode_t::output);
-        gpio_hi(_cfg.pin_dc);
-    }
-}
-
-bool Mesh_Bus_SPI::init(void)
-{
-    dc_h();
-    pinMode(_cfg.pin_dc, pin_mode_t::output);
-    if (SPIName != "")
-        PrivateSPI->begin(SPIName.c_str());
-    else
-        PrivateSPI->begin();
-    return true;
-}
-
-void Mesh_Bus_SPI::release(void)
-{
-    PrivateSPI->end();
-}
-
-void Mesh_Bus_SPI::spi_device(HardwareSPI *newSPI, std::string newSPIName)
-{
-    PrivateSPI = newSPI;
-    SPIName = newSPIName;
-}
-void Mesh_Bus_SPI::beginTransaction(void)
-{
-    dc_h();
-    SPISettings setting(_cfg.freq_write, MSBFIRST, _cfg.spi_mode);
-    PrivateSPI->beginTransaction(setting);
-}
-
-void Mesh_Bus_SPI::endTransaction(void)
-{
-    PrivateSPI->endTransaction();
-    dc_h();
-}
-
-void Mesh_Bus_SPI::beginRead(void)
-{
-    PrivateSPI->endTransaction();
-    // SPISettings setting(_cfg.freq_read, BitOrder::MSBFIRST, _cfg.spi_mode, false);
-    SPISettings setting(_cfg.freq_read, MSBFIRST, _cfg.spi_mode);
-    PrivateSPI->beginTransaction(setting);
-}
-
-void Mesh_Bus_SPI::endRead(void)
-{
-    PrivateSPI->endTransaction();
-    beginTransaction();
-}
-
-void Mesh_Bus_SPI::wait(void) {}
-
-bool Mesh_Bus_SPI::busy(void) const
-{
-    return false;
-}
-
-bool Mesh_Bus_SPI::writeCommand(uint32_t data, uint_fast8_t bit_length)
-{
-    dc_l();
-    PrivateSPI->transfer((uint8_t *)&data, bit_length >> 3);
-    dc_h();
-    return true;
-}
-
-void Mesh_Bus_SPI::writeData(uint32_t data, uint_fast8_t bit_length)
-{
-    PrivateSPI->transfer((uint8_t *)&data, bit_length >> 3);
-}
-
-void Mesh_Bus_SPI::writeDataRepeat(uint32_t data, uint_fast8_t bit_length, uint32_t length)
-{
-    const uint8_t dst_bytes = bit_length >> 3;
-    uint32_t limit = (dst_bytes == 3) ? 12 : 16;
-    auto buf = _flip_buffer.getBuffer(512);
-    size_t fillpos = 0;
-    reinterpret_cast<uint32_t *>(buf)[0] = data;
-    fillpos += dst_bytes;
-    uint32_t len;
-    do {
-        len = ((length - 1) % limit) + 1;
-        if (limit <= 64)
-            limit <<= 1;
-
-        while (fillpos < len * dst_bytes) {
-            memcpy(&buf[fillpos], buf, fillpos);
-            fillpos += fillpos;
-        }
-
-        PrivateSPI->transfer(buf, len * dst_bytes);
-    } while (length -= len);
-}
-
-void Mesh_Bus_SPI::writePixels(pixelcopy_t *param, uint32_t length)
-{
-    const uint8_t dst_bytes = param->dst_bits >> 3;
-    uint32_t limit = (dst_bytes == 3) ? 12 : 16;
-    uint32_t len;
-    do {
-        len = ((length - 1) % limit) + 1;
-        if (limit <= 32)
-            limit <<= 1;
-        auto buf = _flip_buffer.getBuffer(len * dst_bytes);
-        param->fp_copy(buf, 0, len, param);
-        PrivateSPI->transfer(buf, len * dst_bytes);
-    } while (length -= len);
-}
-
-void Mesh_Bus_SPI::writeBytes(const uint8_t *data, uint32_t length, bool dc, bool use_dma)
-{
-    if (dc)
-        dc_h();
-    else
-        dc_l();
-    PrivateSPI->transfer(const_cast<uint8_t *>(data), length);
-    if (!dc)
-        dc_h();
-}
-
-uint32_t Mesh_Bus_SPI::readData(uint_fast8_t bit_length)
-{
-    uint32_t res = 0;
-    bit_length >>= 3;
-    if (!bit_length)
-        return res;
-    int idx = 0;
-    do {
-        res |= PrivateSPI->transfer(0) << idx;
-        idx += 8;
-    } while (--bit_length);
-    return res;
-}
-
-bool Mesh_Bus_SPI::readBytes(uint8_t *dst, uint32_t length, bool use_dma)
-{
-    do {
-        dst[0] = PrivateSPI->transfer(0);
-        ++dst;
-    } while (--length);
-    return true;
-}
-
-void Mesh_Bus_SPI::readPixels(void *dst, pixelcopy_t *param, uint32_t length)
-{
-    uint32_t bytes = param->src_bits >> 3;
-    uint32_t dstindex = 0;
-    uint32_t len = 4;
-    uint8_t buf[24];
-    param->src_data = buf;
-    do {
-        if (len > length)
-            len = length;
-        readBytes((uint8_t *)buf, len * bytes, true);
-        param->src_x = 0;
-        dstindex = param->fp_copy(dst, dstindex, dstindex + len, param);
-        length -= len;
-    } while (length);
-}
-
-} // namespace v1
-} // namespace lgfx
-#endif

src/graphics/mesh_bus_spi.h

@@ -1,100 +0,0 @@
-#if ARCH_PORTDUINO
-/*----------------------------------------------------------------------------/
-  Lovyan GFX - Graphics library for embedded devices.
-
-Original Source:
- https://github.com/lovyan03/LovyanGFX/
-
-Licence:
- [FreeBSD](https://github.com/lovyan03/LovyanGFX/blob/master/license.txt)
-
-Author:
- [lovyan03](https://twitter.com/lovyan03)
-
-Contributors:
- [ciniml](https://github.com/ciniml)
- [mongonta0716](https://github.com/mongonta0716)
- [tobozo](https://github.com/tobozo)
-/----------------------------------------------------------------------------*/
-#pragma once
-
-#include <stdint.h>
-
-#include "lgfx/v1/Bus.hpp"
-#include "lgfx/v1/platforms/common.hpp"
-
-namespace lgfx
-{
-inline namespace v1
-{
-//----------------------------------------------------------------------------
-
-class Mesh_Bus_SPI : public IBus
-{
-  public:
-    struct config_t {
-        uint32_t freq_write = 16000000;
-        uint32_t freq_read = 8000000;
-        // bool spi_3wire = true;
-        // bool use_lock = true;
-        int16_t pin_sclk = -1;
-        int16_t pin_miso = -1;
-        int16_t pin_mosi = -1;
-        int16_t pin_dc = -1;
-        uint8_t spi_mode = 0;
-    };
-
-    const config_t &config(void) const { return _cfg; }
-
-    void config(const config_t &config);
-
-    bus_type_t busType(void) const override { return bus_type_t::bus_spi; }
-
-    bool init(void) override;
-    void release(void) override;
-    void spi_device(HardwareSPI *newSPI, std::string newSPIName);
-
-    void beginTransaction(void) override;
-    void endTransaction(void) override;
-    void wait(void) override;
-    bool busy(void) const override;
-
-    bool writeCommand(uint32_t data, uint_fast8_t bit_length) override;
-    void writeData(uint32_t data, uint_fast8_t bit_length) override;
-    void writeDataRepeat(uint32_t data, uint_fast8_t bit_length, uint32_t count) override;
-    void writePixels(pixelcopy_t *param, uint32_t length) override;
-    void writeBytes(const uint8_t *data, uint32_t length, bool dc, bool use_dma) override;
-
-    void initDMA(void) {}
-    void flush(void) {}
-    void addDMAQueue(const uint8_t *data, uint32_t length) override { writeBytes(data, length, true, true); }
-    void execDMAQueue(void) {}
-    uint8_t *getDMABuffer(uint32_t length) override { return _flip_buffer.getBuffer(length); }
-
-    void beginRead(void) override;
-    void endRead(void) override;
-    uint32_t readData(uint_fast8_t bit_length) override;
-    bool readBytes(uint8_t *dst, uint32_t length, bool use_dma) override;
-    void readPixels(void *dst, pixelcopy_t *param, uint32_t length) override;
-
-  private:
-    HardwareSPI *PrivateSPI;
-    std::string SPIName;
-    __attribute__((always_inline)) inline void dc_h(void) { gpio_hi(_cfg.pin_dc); }
-    __attribute__((always_inline)) inline void dc_l(void) { gpio_lo(_cfg.pin_dc); }
-
-    config_t _cfg;
-    FlipBuffer _flip_buffer;
-    bool _need_wait;
-    uint32_t _mask_reg_dc;
-    uint32_t _last_apb_freq = -1;
-    uint32_t _clkdiv_write;
-    uint32_t _clkdiv_read;
-    volatile uint32_t *_gpio_reg_dc_h;
-    volatile uint32_t *_gpio_reg_dc_l;
-};
-
-//----------------------------------------------------------------------------
-} // namespace v1
-} // namespace lgfx
-#endif