logo

qmk_firmware

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

qp_sh1107.c (9670B)

    

  1. #include "qp_internal.h"
  2. #include "qp_comms.h"
  3. #include "qp_surface_internal.h"
  4. #include "qp_oled_panel.h"
  5. #include "qp_sh1107.h"
  6. #include "qp_sh1107_opcodes.h"
  7. #include "qp_surface.h"
  9. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  10. // Driver storage
  11. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  13. typedef struct sh1107_device_t {
  14.     oled_panel_painter_device_t oled;
  16.     uint8_t framebuffer[SURFACE_REQUIRED_BUFFER_BYTE_SIZE(128, 128, 1)];
  17. } sh1107_device_t;
  19. static sh1107_device_t sh1107_drivers[SH1107_NUM_DEVICES] = {0};
  21. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  22. // Quantum Painter API implementations
  24. // Initialisation
  25. __attribute__((weak)) bool qp_sh1107_init(painter_device_t device, painter_rotation_t rotation) {
  26.     sh1107_device_t *driver = (sh1107_device_t *)device;
  28.     // Change the surface geometry based on the panel rotation
  29.     if (rotation == QP_ROTATION_90 || rotation == QP_ROTATION_270) {
  30.         driver->oled.surface.base.panel_width  = driver->oled.base.panel_height;
  31.         driver->oled.surface.base.panel_height = driver->oled.base.panel_width;
  32.     } else {
  33.         driver->oled.surface.base.panel_width  = driver->oled.base.panel_width;
  34.         driver->oled.surface.base.panel_height = driver->oled.base.panel_height;
  35.     }
  37.     // Init the internal surface
  38.     if (!qp_init(&driver->oled.surface.base, QP_ROTATION_0)) {
  39.         qp_dprintf("Failed to init internal surface in qp_sh1107_init\n");
  40.         return false;
  41.     }
  43.     // clang-format off
  44.     uint8_t sh1107_init_sequence[] = {
  45.         // Command,                 Delay,  N, Data[N]
  46.         SH1107_SET_MUX_RATIO,           0,  1, 0x7F,      // 1/128 duty
  47.         SH1107_DISPLAY_OFFSET,          0,  1, 0x00,
  48.         SH1107_SET_START_LINE,          0,  1, 0x00,      // Different from SH1106
  49.         SH1107_SET_SEGMENT_REMAP_INV,   0,  0,
  50.         SH1107_COM_SCAN_DIR_DEC,        0,  0,
  51.         SH1107_COM_PADS_HW_CFG,         0,  1, 0x12,
  52.         SH1107_SET_CONTRAST,            0,  1, 0x7F,
  53.         SH1107_ALL_ON_RESUME,           0,  0,
  54.         SH1107_NON_INVERTING_DISPLAY,   0,  0,
  55.         SH1107_SET_OSC_DIVFREQ,         0,  1, 0x80,
  56.         SH1107_SET_CHARGE_PUMP,         0,  1, 0x14,
  57.         SH1107_DISPLAY_ON,              0,  0,
  58.     };
  59.     // clang-format on
  61.     // If the display width is anything other than the default 128 pixels, change SH1107_SET_MUX_RATIO data byte to the correct value.
  62.     if (driver->oled.base.panel_width != 128) {
  63.         sh1107_init_sequence[3] = driver->oled.base.panel_width - 1;
  64.     }
  66.     // If the display width is less than the default 128 pixels, change SH1107_DISPLAY_OFFSET to use the center columns.
  67.     if (driver->oled.base.panel_width < 128) {
  68.         sh1107_init_sequence[7] = (128U - driver->oled.base.panel_width) / 2;
  69.     }
  71.     // For smaller displays, change SH1107_COM_PADS_HW_CFG data byte from alternative (0x12) to sequential (0x02) configuration
  72.     if (driver->oled.base.panel_height <= 64) {
  73.         sh1107_init_sequence[20] = 0x02;
  74.     }
  76.     qp_comms_bulk_command_sequence(device, sh1107_init_sequence, sizeof(sh1107_init_sequence));
  77.     return true;
  78. }
  80. // Screen flush
  81. bool qp_sh1107_flush(painter_device_t device) {
  82.     sh1107_device_t *driver = (sh1107_device_t *)device;
  84.     if (!driver->oled.surface.dirty.is_dirty) {
  85.         return true;
  86.     }
  88.     switch (driver->oled.base.rotation) {
  89.         default:
  90.         case QP_ROTATION_0:
  91.             qp_oled_panel_page_column_flush_rot0(device, &driver->oled.surface.dirty, driver->framebuffer);
  92.             break;
  93.         case QP_ROTATION_90:
  94.             qp_oled_panel_page_column_flush_rot90(device, &driver->oled.surface.dirty, driver->framebuffer);
  95.             break;
  96.         case QP_ROTATION_180:
  97.             qp_oled_panel_page_column_flush_rot180(device, &driver->oled.surface.dirty, driver->framebuffer);
  98.             break;
  99.         case QP_ROTATION_270:
  100.             qp_oled_panel_page_column_flush_rot270(device, &driver->oled.surface.dirty, driver->framebuffer);
  101.             break;
  102.     }
  104.     // Clear the dirty area
  105.     qp_flush(&driver->oled.surface);
  107.     return true;
  108. }
  110. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  111. // Driver vtable
  112. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  114. const oled_panel_painter_driver_vtable_t sh1107_driver_vtable = {
  115.     .base =
  116.         {
  117.             .init            = qp_sh1107_init,
  118.             .power           = qp_oled_panel_power,
  119.             .clear           = qp_oled_panel_clear,
  120.             .flush           = qp_sh1107_flush,
  121.             .pixdata         = qp_oled_panel_passthru_pixdata,
  122.             .viewport        = qp_oled_panel_passthru_viewport,
  123.             .palette_convert = qp_oled_panel_passthru_palette_convert,
  124.             .append_pixels   = qp_oled_panel_passthru_append_pixels,
  125.             .append_pixdata  = qp_oled_panel_passthru_append_pixdata,
  126.         },
  127.     .opcodes =
  128.         {
  129.             .display_on     = SH1107_DISPLAY_ON,
  130.             .display_off    = SH1107_DISPLAY_OFF,
  131.             .set_page       = SH1107_PAGE_ADDR,
  132.             .set_column_lsb = SH1107_SETCOLUMN_LSB,
  133.             .set_column_msb = SH1107_SETCOLUMN_MSB,
  134.         },
  135. };
  137. #ifdef QUANTUM_PAINTER_SH1107_SPI_ENABLE
  138. // Factory function for creating a handle to the SH1107 device
  139. painter_device_t qp_sh1107_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) {
  140.     for (uint32_t i = 0; i < SH1107_NUM_DEVICES; ++i) {
  141.         sh1107_device_t *driver = &sh1107_drivers[i];
  142.         if (!driver->oled.base.driver_vtable) {
  143.             painter_device_t surface = qp_make_mono1bpp_surface_advanced(&driver->oled.surface, 1, panel_width, panel_height, driver->framebuffer);
  144.             if (!surface) {
  145.                 return NULL;
  146.             }
  148.             // Setup the OLED device
  149.             driver->oled.base.driver_vtable         = (const painter_driver_vtable_t *)&sh1107_driver_vtable;
  150.             driver->oled.base.comms_vtable          = (const painter_comms_vtable_t *)&spi_comms_with_dc_vtable;
  151.             driver->oled.base.native_bits_per_pixel = 1; // 1bpp mono
  152.             driver->oled.base.panel_width           = panel_width;
  153.             driver->oled.base.panel_height          = panel_height;
  154.             driver->oled.base.rotation              = QP_ROTATION_0;
  155.             driver->oled.base.offset_x              = 0;
  156.             driver->oled.base.offset_y              = 0;
  158.             // SPI and other pin configuration
  159.             driver->oled.base.comms_config                                   = &driver->oled.spi_dc_reset_config;
  160.             driver->oled.spi_dc_reset_config.spi_config.chip_select_pin      = chip_select_pin;
  161.             driver->oled.spi_dc_reset_config.spi_config.divisor              = spi_divisor;
  162.             driver->oled.spi_dc_reset_config.spi_config.lsb_first            = false;
  163.             driver->oled.spi_dc_reset_config.spi_config.mode                 = spi_mode;
  164.             driver->oled.spi_dc_reset_config.dc_pin                          = dc_pin;
  165.             driver->oled.spi_dc_reset_config.reset_pin                       = reset_pin;
  166.             driver->oled.spi_dc_reset_config.command_params_uses_command_pin = true;
  168.             if (!qp_internal_register_device((painter_device_t)driver)) {
  169.                 memset(driver, 0, sizeof(sh1107_device_t));
  170.                 return NULL;
  171.             }
  173.             return (painter_device_t)driver;
  174.         }
  175.     }
  176.     return NULL;
  177. }
  179. #endif // QUANTUM_PAINTER_SH1107_SPI_ENABLE
  181. #ifdef QUANTUM_PAINTER_SH1107_I2C_ENABLE
  182. // Factory function for creating a handle to the SH1107 device
  183. painter_device_t qp_sh1107_make_i2c_device(uint16_t panel_width, uint16_t panel_height, uint8_t i2c_address) {
  184.     for (uint32_t i = 0; i < SH1107_NUM_DEVICES; ++i) {
  185.         sh1107_device_t *driver = &sh1107_drivers[i];
  186.         if (!driver->oled.base.driver_vtable) {
  187.             // Instantiate the surface
  188.             painter_device_t surface = qp_make_mono1bpp_surface_advanced(&driver->oled.surface, 1, panel_width, panel_height, driver->framebuffer);
  189.             if (!surface) {
  190.                 return NULL;
  191.             }
  193.             // Setup the OLED device
  194.             driver->oled.base.driver_vtable         = (const painter_driver_vtable_t *)&sh1107_driver_vtable;
  195.             driver->oled.base.comms_vtable          = (const painter_comms_vtable_t *)&i2c_comms_cmddata_vtable;
  196.             driver->oled.base.native_bits_per_pixel = 1; // 1bpp mono
  197.             driver->oled.base.panel_width           = panel_width;
  198.             driver->oled.base.panel_height          = panel_height;
  199.             driver->oled.base.rotation              = QP_ROTATION_0;
  200.             driver->oled.base.offset_x              = 0;
  201.             driver->oled.base.offset_y              = 0;
  203.             // I2C configuration
  204.             driver->oled.base.comms_config       = &driver->oled.i2c_config;
  205.             driver->oled.i2c_config.chip_address = i2c_address;
  207.             if (!qp_internal_register_device((painter_device_t)driver)) {
  208.                 memset(driver, 0, sizeof(sh1107_device_t));
  209.                 return NULL;
  210.             }
  212.             return (painter_device_t)driver;
  213.         }
  214.     }
  215.     return NULL;
  216. }
  218. #endif // QUANTUM_PAINTER_SH1107_I2C_ENABLE