logo

qmk_firmware

custom branch of QMK firmware git clone https://anongit.hacktivis.me/git/qmk_firmware.git

qp_ld7032.c (18051B)

    

  1. // Copyright 2023 Nick Brassel (@tzarc)
  2. // Copyright 2023 Dasky (@daskygit)
  3. // SPDX-License-Identifier: GPL-2.0-or-later
  5. #include "qp_internal.h"
  6. #include "qp_comms.h"
  7. #include "qp_oled_panel.h"
  8. #include "qp_ld7032.h"
  9. #include "qp_ld7032_opcodes.h"
  10. #include "qp_surface.h"
  11. #include "qp_surface_internal.h"
  13. typedef void (*ld7032_driver_comms_send_command_and_data_func)(painter_device_t device, uint8_t cmd, uint8_t data);
  14. typedef uint32_t (*ld7032_driver_comms_send_command_and_databuf_func)(painter_device_t device, uint8_t cmd, const void *data, uint32_t byte_count);
  16. typedef struct ld7032_comms_with_command_vtable_t {
  17.     painter_comms_vtable_t                            base; // must be first, so this object can be cast from the painter_comms_vtable_t* type
  18.     painter_driver_comms_send_command_func            send_command;
  19.     painter_driver_comms_bulk_command_sequence        bulk_command_sequence;
  20.     ld7032_driver_comms_send_command_and_data_func    send_command_data;
  21.     ld7032_driver_comms_send_command_and_databuf_func send_command_databuf;
  22. } ld7032_comms_with_command_vtable_t;
  24. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  25. // LD7032 Internal API
  26. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  28. void ld7032_comms_i2c_send_command_and_data(painter_device_t device, uint8_t cmd, uint8_t data) {
  29.     uint8_t buf[2] = {cmd, data};
  30.     qp_comms_i2c_send_data(device, buf, 2);
  31. }
  33. void ld7032_comms_i2c_bulk_command_sequence(painter_device_t device, const uint8_t *sequence, size_t sequence_len) {
  34.     uint8_t buf[32];
  35.     for (size_t i = 0; i < sequence_len;) {
  36.         uint8_t command   = sequence[i];
  37.         uint8_t delay     = sequence[i + 1];
  38.         uint8_t num_bytes = sequence[i + 2];
  39.         buf[0]            = command;
  40.         memcpy(&buf[1], &sequence[i + 3], num_bytes);
  41.         qp_comms_i2c_send_data(device, buf, num_bytes + 1);
  42.         if (delay > 0) {
  43.             wait_ms(delay);
  44.         }
  45.         i += (3 + num_bytes);
  46.     }
  47. }
  49. uint32_t ld7032_comms_i2c_send_command_and_databuf(painter_device_t device, uint8_t cmd, const void *data, uint32_t byte_count) {
  50.     uint8_t buf[byte_count + 1];
  51.     memset(buf, 0, sizeof(buf));
  52.     buf[0] = cmd;
  53.     memcpy(&buf[1], data, byte_count);
  54.     return qp_comms_send(device, buf, byte_count + 1);
  55. }
  57. // Power control
  58. bool qp_ld7032_power(painter_device_t device, bool power_on) {
  59.     painter_driver_t *                  driver       = (painter_driver_t *)device;
  60.     ld7032_comms_with_command_vtable_t *comms_vtable = (ld7032_comms_with_command_vtable_t *)driver->comms_vtable;
  62.     comms_vtable->send_command_data(device, LD7032_DISP_ON_OFF, power_on ? 0x01 : 0x00);
  64.     return true;
  65. }
  67. // Screen clear
  68. bool qp_ld7032_clear(painter_device_t device) {
  69.     qp_rect(device, 0, 0, 127, 127, 0, 0, 0, true); // clear memory
  70.     painter_driver_t *driver = (painter_driver_t *)device;
  71.     driver->driver_vtable->init(device, driver->rotation); // Re-init the display
  72.     return true;
  73. }
  75. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  76. // Flush helpers
  77. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  79. void ld7032_flush_0(painter_device_t device, surface_dirty_data_t *dirty, const uint8_t *framebuffer, bool inverted) {
  80.     painter_driver_t *                  driver       = (painter_driver_t *)device;
  81.     ld7032_comms_with_command_vtable_t *comms_vtable = (ld7032_comms_with_command_vtable_t *)driver->comms_vtable;
  83.     int     x_start       = dirty->l >> 3;
  84.     int     x_end         = dirty->r >> 3;
  85.     int     y_start       = dirty->t;
  86.     int     y_end         = dirty->b;
  87.     int     x_length      = (x_end - x_start) + 1;
  88.     uint8_t x_view_offset = driver->offset_x >> 3;
  89.     uint8_t y_view_offset = driver->offset_y;
  91.     for (int y_pos = y_start; y_pos <= y_end; y_pos++) {
  92.         int y_new_pos = y_pos;
  93.         if (inverted) {
  94.             y_new_pos = y_end - y_pos;
  95.         }
  96.         uint8_t packet[x_length];
  97.         memcpy(packet, &framebuffer[(y_pos * (driver->panel_width >> 3)) + x_start], x_length);
  98.         uint8_t x_write_start = MIN(x_start + x_view_offset, (128 >> 3));
  99.         uint8_t x_write_end   = MIN(x_end + x_view_offset, (128 >> 3));
  100.         uint8_t y_write_start = MIN(y_new_pos + y_view_offset, 39);
  101.         uint8_t y_write_end   = MIN(y_new_pos + y_view_offset, 39);
  103.         comms_vtable->send_command_data(device, LD7032_X_BOX_ADR_START, x_write_start);
  104.         comms_vtable->send_command_data(device, LD7032_X_BOX_ADR_END, x_write_end);
  105.         comms_vtable->send_command_data(device, LD7032_Y_BOX_ADR_START, y_write_start);
  106.         comms_vtable->send_command_data(device, LD7032_Y_BOX_ADR_END, y_write_end);
  107.         comms_vtable->send_command_databuf(device, LD7032_DATA_RW, packet, x_length);
  108.     }
  109. }
  111. void ld7032_flush_90(painter_device_t device, surface_dirty_data_t *dirty, const uint8_t *framebuffer, bool inverted) {
  112.     painter_driver_t *                  driver       = (painter_driver_t *)device;
  113.     ld7032_comms_with_command_vtable_t *comms_vtable = (ld7032_comms_with_command_vtable_t *)driver->comms_vtable;
  115.     int     x_start       = dirty->t >> 3;
  116.     int     x_end         = dirty->b >> 3;
  117.     int     y_start       = dirty->l;
  118.     int     y_end         = dirty->r;
  119.     int     x_length      = (x_end - x_start) + 1;
  120.     uint8_t x_view_offset = driver->offset_x >> 3;
  121.     uint8_t y_view_offset = driver->offset_y;
  123.     for (int y_pos = y_start; y_pos <= y_end; y_pos++) {
  124.         int y_new_pos = y_pos;
  125.         if (inverted) {
  126.             y_new_pos = y_end - y_pos;
  127.         }
  128.         uint8_t packet[x_length];
  129.         memset(packet, 0, sizeof(packet));
  130.         int count = 0;
  131.         for (int x_pos = x_start; x_pos <= x_end; x_pos++) {
  132.             for (int x = 0; x < 8; ++x) {
  133.                 uint32_t pixel_num   = (((x_pos << 3) + x) * driver->panel_height) + y_pos;
  134.                 uint32_t byte_offset = pixel_num / 8;
  135.                 uint8_t  bit_offset  = pixel_num % 8;
  136.                 packet[count] |= ((framebuffer[byte_offset] & (1 << bit_offset)) >> bit_offset) << x;
  137.             }
  138.             count++;
  139.         }
  140.         uint8_t x_width       = (driver->panel_width >> 3) - 1;
  141.         uint8_t x_write_start = MAX((int)x_width - x_end - x_view_offset, 0);
  142.         uint8_t x_write_end   = MAX((int)x_width - x_start - x_view_offset, 0);
  143.         uint8_t y_write_start = MIN(y_new_pos + y_view_offset, 39);
  144.         uint8_t y_write_end   = MIN(y_new_pos + y_view_offset, 39);
  146.         comms_vtable->send_command_data(device, LD7032_X_BOX_ADR_START, x_write_start);
  147.         comms_vtable->send_command_data(device, LD7032_X_BOX_ADR_END, x_write_end);
  148.         comms_vtable->send_command_data(device, LD7032_Y_BOX_ADR_START, y_write_start);
  149.         comms_vtable->send_command_data(device, LD7032_Y_BOX_ADR_END, y_write_end);
  150.         comms_vtable->send_command_databuf(device, LD7032_DATA_RW, packet, x_length);
  151.     }
  152. }
  154. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  155. // Driver storage
  156. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  158. typedef struct ld7032_device_t {
  159.     oled_panel_painter_device_t oled;
  161.     uint8_t framebuffer[SURFACE_REQUIRED_BUFFER_BYTE_SIZE(128, 40, 1)];
  162. } ld7032_device_t;
  164. static ld7032_device_t ld7032_drivers[LD7032_NUM_DEVICES] = {0};
  166. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  167. // Quantum Painter API implementations
  169. // Initialisation
  170. __attribute__((weak)) bool qp_ld7032_init(painter_device_t device, painter_rotation_t rotation) {
  171.     ld7032_device_t *driver = (ld7032_device_t *)device;
  173.     // Change the surface geometry based on the panel rotation
  174.     if (rotation == QP_ROTATION_90 || rotation == QP_ROTATION_270) {
  175.         driver->oled.surface.base.panel_width  = driver->oled.base.panel_height;
  176.         driver->oled.surface.base.panel_height = driver->oled.base.panel_width;
  177.     } else {
  178.         driver->oled.surface.base.panel_width  = driver->oled.base.panel_width;
  179.         driver->oled.surface.base.panel_height = driver->oled.base.panel_height;
  180.     }
  182.     // Init the internal surface
  183.     if (!qp_init(&driver->oled.surface.base, QP_ROTATION_0)) {
  184.         qp_dprintf("Failed to init internal surface in qp_ld7032_init\n");
  185.         return false;
  186.     }
  188.     // clang-format off
  189.     const uint8_t ld7032_init_sequence[] = {
  190.         // Command,                    Delay,  N, Data[N]
  191.         LD7032_DISP_STBY_ON_OFF, 0, 1, 0x00,
  192.         LD7032_DISP_ON_OFF,      0, 1, 0x00,
  193.         LD7032_DFRAME,           0, 1, 0x05,
  194.         //LD7032_WRITE_DIRECTION, 0, 1, 0b00001000, // 0 Right, 1 Up, 2 Vertical, 3 Bit Order, 4-7 Unused
  195.         LD7032_DISP_DIRECTION,  0, 1, 0x00,
  196.         LD7032_PEAK_WIDTH,      0, 1, 0x1F,
  197.         LD7032_PEAK_DELAY,      0, 1, 0x05,
  198.         LD7032_SCAN_MODE,       0, 1, 0x01,
  199.         LD7032_DOT_CURRENT,     0, 1, 0x1f,
  200.         LD7032_VDD_SEL,         0, 1, 0x01,
  201.     };
  202.     // clang-format on
  204.     qp_comms_bulk_command_sequence(device, ld7032_init_sequence, sizeof(ld7032_init_sequence));
  206.     uint8_t display_y_start = 40 - driver->oled.base.panel_height;
  207.     uint8_t display_x_start = (128 - driver->oled.base.panel_width) / 2;
  209.     // clang-format off
  210.     uint8_t ld7032_memory_setup[] = {
  211.         // Command,        Delay,  N, Data[N]
  212.         LD7032_DISP_SIZE_X,     0, 2, 0x00, 0x7F,
  213.         LD7032_DISP_SIZE_Y,     0, 2, 0x00, 0x27,
  214.         LD7032_X_DISP_START,    0, 1, 0x0,
  215.         LD7032_Y_DISP_START,    0, 1, 0x0,
  216.     };
  217.     // clang-format on
  219.     ld7032_memory_setup[3]  = display_x_start;
  220.     ld7032_memory_setup[4]  = display_x_start + driver->oled.base.panel_width - 1;
  221.     ld7032_memory_setup[8]  = display_y_start;
  222.     ld7032_memory_setup[9]  = display_y_start + driver->oled.base.panel_height - 1;
  223.     ld7032_memory_setup[13] = ld7032_memory_setup[4] + 1;
  224.     ld7032_memory_setup[17] = driver->oled.base.panel_height;
  226.     qp_comms_bulk_command_sequence(device, ld7032_memory_setup, sizeof(ld7032_memory_setup));
  228.     uint8_t write_direction = 0;
  229.     switch (rotation) {
  230.         default:
  231.         case QP_ROTATION_0:
  232.             write_direction = 0b00001000;
  233.             break;
  234.         case QP_ROTATION_90:
  235.             write_direction = 0b00000001;
  236.             break;
  237.         case QP_ROTATION_180:
  238.             write_direction = 0b00000001;
  239.             break;
  240.         case QP_ROTATION_270:
  241.             write_direction = 0b00001000;
  242.             break;
  243.     }
  245.     painter_driver_t *                  pdriver      = (painter_driver_t *)device;
  246.     ld7032_comms_with_command_vtable_t *comms_vtable = (ld7032_comms_with_command_vtable_t *)pdriver->comms_vtable;
  248.     comms_vtable->send_command_data(device, LD7032_WRITE_DIRECTION, write_direction);
  250.     qp_ld7032_power(device, true);
  252.     return true;
  253. }
  255. // Screen flush
  256. bool qp_ld7032_flush(painter_device_t device) {
  257.     ld7032_device_t *driver = (ld7032_device_t *)device;
  259.     if (!driver->oled.surface.dirty.is_dirty) {
  260.         return true;
  261.     }
  263.     switch (driver->oled.base.rotation) {
  264.         default:
  265.         case QP_ROTATION_0:
  266.             ld7032_flush_0(device, &driver->oled.surface.dirty, driver->framebuffer, false);
  267.             break;
  268.         case QP_ROTATION_180:
  269.             ld7032_flush_0(device, &driver->oled.surface.dirty, driver->framebuffer, true);
  270.             break;
  271.         case QP_ROTATION_90:
  272.             ld7032_flush_90(device, &driver->oled.surface.dirty, driver->framebuffer, false);
  273.             break;
  274.         case QP_ROTATION_270:
  275.             ld7032_flush_90(device, &driver->oled.surface.dirty, driver->framebuffer, true);
  276.             break;
  277.     }
  279.     // Clear the dirty area
  280.     qp_flush(&driver->oled.surface);
  282.     return true;
  283. }
  285. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  286. // Driver vtable
  287. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  289. const painter_driver_vtable_t ld7032_driver_vtable = {
  290.     .init            = qp_ld7032_init,
  291.     .power           = qp_ld7032_power,
  292.     .clear           = qp_ld7032_clear,
  293.     .flush           = qp_ld7032_flush,
  294.     .pixdata         = qp_oled_panel_passthru_pixdata,
  295.     .viewport        = qp_oled_panel_passthru_viewport,
  296.     .palette_convert = qp_oled_panel_passthru_palette_convert,
  297.     .append_pixels   = qp_oled_panel_passthru_append_pixels,
  298.     .append_pixdata  = qp_oled_panel_passthru_append_pixdata,
  299. };
  301. #ifdef QUANTUM_PAINTER_LD7032_SPI_ENABLE
  303. const ld7032_comms_with_command_vtable_t ld7032_spi_comms_vtable = {
  304.     .base =
  305.         {
  306.             .comms_init  = qp_comms_spi_dc_reset_init,
  307.             .comms_start = qp_comms_spi_start,
  308.             .comms_send  = qp_comms_spi_dc_reset_send_data,
  309.             .comms_stop  = qp_comms_spi_stop,
  310.         },
  311.     .send_command          = qp_comms_spi_dc_reset_send_command,
  312.     .send_command_data     = qp_comms_command_databyte,
  313.     .send_command_databuf  = qp_comms_command_databuf,
  314.     .bulk_command_sequence = qp_comms_spi_dc_reset_bulk_command_sequence,
  315. };
  317. // Factory function for creating a handle to the LD7032 device
  318. painter_device_t qp_ld7032_make_spi_device(uint16_t panel_width, uint16_t panel_height, pin_t chip_select_pin, pin_t dc_pin, pin_t reset_pin, uint16_t spi_divisor, int spi_mode) {
  319.     for (uint32_t i = 0; i < LD7032_NUM_DEVICES; ++i) {
  320.         ld7032_device_t *driver = &ld7032_drivers[i];
  321.         if (!driver->oled.base.driver_vtable) {
  322.             painter_device_t surface = qp_make_mono1bpp_surface_advanced(&driver->oled.surface, 1, panel_width, panel_height, driver->framebuffer);
  323.             if (!surface) {
  324.                 return NULL;
  325.             }
  327.             // Setup the OLED device
  328.             driver->oled.base.driver_vtable         = (const painter_driver_vtable_t *)&ld7032_driver_vtable;
  329.             driver->oled.base.comms_vtable          = (const painter_comms_vtable_t *)&ld7032_spi_comms_vtable;
  330.             driver->oled.base.native_bits_per_pixel = 1; // 1bpp mono
  331.             driver->oled.base.panel_width           = panel_width;
  332.             driver->oled.base.panel_height          = panel_height;
  333.             driver->oled.base.rotation              = QP_ROTATION_0;
  334.             driver->oled.base.offset_x              = 0;
  335.             driver->oled.base.offset_y              = 0;
  337.             // SPI and other pin configuration
  338.             driver->oled.base.comms_config                                   = &driver->oled.spi_dc_reset_config;
  339.             driver->oled.spi_dc_reset_config.spi_config.chip_select_pin      = chip_select_pin;
  340.             driver->oled.spi_dc_reset_config.spi_config.divisor              = spi_divisor;
  341.             driver->oled.spi_dc_reset_config.spi_config.lsb_first            = false;
  342.             driver->oled.spi_dc_reset_config.spi_config.mode                 = spi_mode;
  343.             driver->oled.spi_dc_reset_config.dc_pin                          = dc_pin;
  344.             driver->oled.spi_dc_reset_config.reset_pin                       = reset_pin;
  345.             driver->oled.spi_dc_reset_config.command_params_uses_command_pin = true;
  347.             if (!qp_internal_register_device((painter_device_t)driver)) {
  348.                 memset(driver, 0, sizeof(ld7032_device_t));
  349.                 return NULL;
  350.             }
  352.             return (painter_device_t)driver;
  353.         }
  354.     }
  355.     return NULL;
  356. }
  358. #endif // QUANTUM_PAINTER_LD7032_SPI_ENABLE
  360. #ifdef QUANTUM_PAINTER_LD7032_I2C_ENABLE
  362. const ld7032_comms_with_command_vtable_t ld7032_i2c_comms_vtable = {
  363.     .base =
  364.         {
  365.             .comms_init  = qp_comms_i2c_init,
  366.             .comms_start = qp_comms_i2c_start,
  367.             .comms_send  = qp_comms_i2c_send_data,
  368.             .comms_stop  = qp_comms_i2c_stop,
  369.         },
  370.     .send_command          = NULL,
  371.     .send_command_data     = ld7032_comms_i2c_send_command_and_data,
  372.     .send_command_databuf  = ld7032_comms_i2c_send_command_and_databuf,
  373.     .bulk_command_sequence = ld7032_comms_i2c_bulk_command_sequence,
  374. };
  376. // Factory function for creating a handle to the LD7032 device
  377. painter_device_t qp_ld7032_make_i2c_device(uint16_t panel_width, uint16_t panel_height, uint8_t i2c_address) {
  378.     for (uint32_t i = 0; i < LD7032_NUM_DEVICES; ++i) {
  379.         ld7032_device_t *driver = &ld7032_drivers[i];
  380.         if (!driver->oled.base.driver_vtable) {
  381.             painter_device_t surface = qp_make_mono1bpp_surface_advanced(&driver->oled.surface, 1, panel_width, panel_height, driver->framebuffer);
  382.             if (!surface) {
  383.                 return NULL;
  384.             }
  386.             // Setup the OLED device
  387.             driver->oled.base.driver_vtable         = (const painter_driver_vtable_t *)&ld7032_driver_vtable;
  388.             driver->oled.base.comms_vtable          = (const painter_comms_vtable_t *)&ld7032_i2c_comms_vtable;
  389.             driver->oled.base.native_bits_per_pixel = 1; // 1bpp mono
  390.             driver->oled.base.panel_width           = panel_width;
  391.             driver->oled.base.panel_height          = panel_height;
  392.             driver->oled.base.rotation              = QP_ROTATION_0;
  393.             driver->oled.base.offset_x              = 0;
  394.             driver->oled.base.offset_y              = 0;
  396.             // I2C configuration
  397.             driver->oled.base.comms_config       = &driver->oled.i2c_config;
  398.             driver->oled.i2c_config.chip_address = i2c_address;
  400.             if (!qp_internal_register_device((painter_device_t)driver)) {
  401.                 memset(driver, 0, sizeof(ld7032_device_t));
  402.                 return NULL;
  403.             }
  405.             return (painter_device_t)driver;
  406.         }
  407.     }
  408.     return NULL;
  409. }
  411. #endif // QUANTUM_PAINTER_LD7032_SPI_ENABLE