T3W1 PCB bring-up

core/SConscript.firmware

@@ -28,7 +28,7 @@ FEATURE_FLAGS = {
     "AES_GCM": BENCHMARK or THP,
 }
 
-FEATURES_WANTED = ["input", "sbu", "sd_card", "rgb_led", "dma2d", "consumption_mask", "usb" ,"optiga", "haptic"]
+FEATURES_WANTED = ["input", "sd_card", "rgb_led", "dma2d", "consumption_mask", "usb" ,"optiga", "haptic"]
 if DISABLE_OPTIGA and PYOPT == '0':
     FEATURES_WANTED.remove("optiga")
 

core/SConscript.kernel

@@ -23,7 +23,7 @@ FEATURE_FLAGS = {
     "AES_GCM": False,
 }
 
-FEATURES_WANTED = ["input", "sbu", "sd_card", "rgb_led", "dma2d", "consumption_mask", "usb" ,"optiga", "haptic"]
+FEATURES_WANTED = ["input", "sd_card", "rgb_led", "dma2d", "consumption_mask", "usb" ,"optiga", "haptic"]
 if DISABLE_OPTIGA and PYOPT == '0':
     FEATURES_WANTED.remove("optiga")
 

core/SConscript.unix

@@ -20,7 +20,7 @@ if BENCHMARK and PYOPT != '0':
   print("BENCHMARK=1 works only with PYOPT=0.")
   exit(1)
 
-FEATURES_WANTED = ["input", "sd_card", "dma2d", "optiga", "sbu"]
+FEATURES_WANTED = ["input", "sd_card", "dma2d", "optiga"]
 
 if not models.has_emulator(TREZOR_MODEL):
     # skip unix build

core/embed/io/display/st7785ma/display_driver.c

@@ -1,24 +1,88 @@
 
+#include <sys/systick.h>
+#ifdef KERNEL_MODE
+
 #include <trezor_bsp.h>
 #include <trezor_model.h>
 #include <trezor_rtl.h>
 
 #include <io/display.h>
+#include <sys/mpu.h>
+#include <sys/trustzone.h>
+#include "../backlight/backlight_pwm.h"
 
-#ifdef KERNEL_MODE
-void display_init(display_content_mode_t mode) {}
+// Hardware requires physical frame buffer alignment
+#ifdef USE_TRUSTZONE
+#define PHYSICAL_FRAME_BUFFER_ALIGNMENT TZ_SRAM_ALIGNMENT
+#else
+#define PHYSICAL_FRAME_BUFFER_ALIGNMENT 32
+#endif
+
+// Size of the physical frame buffer in bytes
+#define PHYSICAL_FRAME_BUFFER_SIZE               \
+  ALIGN_UP_CONST(DISPLAY_RESX *DISPLAY_RESY * 2, \
+                 PHYSICAL_FRAME_BUFFER_ALIGNMENT)
+
+static
+    __attribute__((section(".fb1"), aligned(PHYSICAL_FRAME_BUFFER_ALIGNMENT)))
+    uint8_t physical_frame_buffer_0[PHYSICAL_FRAME_BUFFER_SIZE];
+
+#if (FRAME_BUFFER_COUNT > 1)
+static
+    __attribute__((section(".fb2"), aligned(PHYSICAL_FRAME_BUFFER_ALIGNMENT)))
+    uint8_t physical_frame_buffer_1[PHYSICAL_FRAME_BUFFER_SIZE];
+#endif
+
+void display_init(display_content_mode_t mode) {
+  __HAL_RCC_GPIOE_CLK_ENABLE();
 
-void display_deinit(display_content_mode_t mode) {}
+  GPIO_InitTypeDef GPIO_InitStructure;
+
+  GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_PP;
+  GPIO_InitStructure.Pull = GPIO_NOPULL;
+  GPIO_InitStructure.Speed = GPIO_SPEED_FREQ_LOW;
+  GPIO_InitStructure.Alternate = 0;
+  GPIO_InitStructure.Pin = GPIO_PIN_2;
+  HAL_GPIO_WritePin(GPIOE, GPIO_PIN_2, GPIO_PIN_RESET);
+  HAL_GPIO_Init(GPIOE, &GPIO_InitStructure);
+
+  GPIO_InitStructure.Pin = GPIO_PIN_0;
+  // default to keeping display in reset
+  HAL_GPIO_WritePin(GPIOE, GPIO_PIN_0, GPIO_PIN_RESET);
+  HAL_GPIO_Init(GPIOE, &GPIO_InitStructure);
+
+  hal_delay(100);
+  HAL_GPIO_WritePin(GPIOE, GPIO_PIN_2, GPIO_PIN_SET);
+
+  backlight_pwm_init(mode);
+}
+
+void display_deinit(display_content_mode_t mode) { backlight_pwm_deinit(mode); }
 
 void display_set_unpriv_access(bool unpriv) {}
 
-int display_set_backlight(int level) { return level; }
+int display_set_backlight(int level) {
+  return 0;
+  // return backlight_pwm_set(level);
+}
 
-int display_get_backlight(void) { return 0; }
+int display_get_backlight(void) { return backlight_pwm_get(); }
 
 int display_set_orientation(int angle) { return angle; }
 int display_get_orientation(void) { return 0; }
-bool display_get_frame_buffer(display_fb_info_t *fb) { return true; }
+
+// Returns the pointer to the physical frame buffer (0.. FRAME_BUFFER_COUNT-1)
+// Returns NULL if the framebuffer index is out of range.
+static uint8_t *get_fb_ptr(uint32_t index) { return physical_frame_buffer_0; }
+
+bool display_get_frame_buffer(display_fb_info_t *fb) {
+  fb->ptr = get_fb_ptr(0);
+  fb->stride = DISPLAY_RESX * sizeof(uint16_t);
+  // Enable access to the frame buffer from the unprivileged code
+  mpu_set_unpriv_fb(fb->ptr, PHYSICAL_FRAME_BUFFER_SIZE);
+
+  return true;
+}
 
 void display_refresh(void) {}
 void display_fill(const gfx_bitblt_t *bb) {}

core/embed/io/rgb_led/inc/io/rgb_led.h

@@ -24,10 +24,16 @@
 
 #ifdef KERNEL_MODE
 
+// Initialize RGB LED driver
 void rgb_led_init(void);
 
+// Deinitialize RGB LED driver
+void rgb_led_deinit(void);
+
 #endif
 
+// Set RGB LED color
+// color: 24-bit RGB color, 0x00RRGGBB
 void rgb_led_set_color(uint32_t color);
 
 #endif  // TREZORHAL_RGB_LED_H

core/embed/io/rgb_led/stm32/rgb_led.c

@@ -0,0 +1,96 @@
+#ifdef KERNEL_MODE
+
+#include <trezor_bsp.h>
+#include <trezor_model.h>
+#include <trezor_rtl.h>
+
+#include <io/rgb_led.h>
+
+#define LED_SWITCHING_FREQUENCY_HZ 20000
+#define TIMER_PERIOD (SystemCoreClock / LED_SWITCHING_FREQUENCY_HZ)
+
+typedef struct {
+  TIM_HandleTypeDef tim;
+  bool initialized;
+} rgb_led_t;
+
+static rgb_led_t g_rgb_led = {0};
+
+void rgb_led_init(void) {
+  rgb_led_t* drv = &g_rgb_led;
+  if (drv->initialized) {
+    return;
+  }
+
+  memset(drv, 0, sizeof(*drv));
+
+  __HAL_RCC_GPIOB_CLK_ENABLE();
+  __HAL_RCC_TIM4_CLK_ENABLE();
+  __HAL_RCC_TIM4_FORCE_RESET();
+  __HAL_RCC_TIM4_RELEASE_RESET();
+
+  GPIO_InitTypeDef GPIO_InitStructure = {0};
+  GPIO_InitStructure.Pin = GPIO_PIN_6 | GPIO_PIN_7 | GPIO_PIN_8;
+  GPIO_InitStructure.Mode = GPIO_MODE_AF_OD;
+  GPIO_InitStructure.Pull = GPIO_NOPULL;
+  GPIO_InitStructure.Speed = GPIO_SPEED_FREQ_LOW;
+  GPIO_InitStructure.Alternate = GPIO_AF2_TIM4;
+  HAL_GPIO_Init(GPIOB, &GPIO_InitStructure);
+
+  drv->tim.State = HAL_TIM_STATE_RESET;
+  drv->tim.Instance = TIM4;
+  drv->tim.Init.Period = TIMER_PERIOD;
+  drv->tim.Init.Prescaler = 0;
+  drv->tim.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
+  drv->tim.Init.CounterMode = TIM_COUNTERMODE_UP;
+  drv->tim.Init.RepetitionCounter = 0;
+  HAL_TIM_PWM_Init(&drv->tim);
+
+  // OC initialization
+  TIM_OC_InitTypeDef OC_Init = {0};
+  OC_Init.OCMode = TIM_OCMODE_PWM2;
+  OC_Init.Pulse = 0;
+  OC_Init.OCPolarity = TIM_OCPOLARITY_HIGH;
+  OC_Init.OCFastMode = TIM_OCFAST_DISABLE;
+  OC_Init.OCIdleState = TIM_OCIDLESTATE_RESET;
+  HAL_TIM_PWM_ConfigChannel(&drv->tim, &OC_Init, TIM_CHANNEL_1);
+  HAL_TIM_PWM_ConfigChannel(&drv->tim, &OC_Init, TIM_CHANNEL_2);
+  HAL_TIM_PWM_ConfigChannel(&drv->tim, &OC_Init, TIM_CHANNEL_3);
+
+  HAL_TIM_Base_Start(&drv->tim);
+
+  HAL_TIM_PWM_Start(&drv->tim, TIM_CHANNEL_1);
+  HAL_TIM_PWM_Start(&drv->tim, TIM_CHANNEL_2);
+  HAL_TIM_PWM_Start(&drv->tim, TIM_CHANNEL_3);
+
+  drv->initialized = true;
+}
+
+void rgb_led_deinit(void) {
+  rgb_led_t* drv = &g_rgb_led;
+  if (!drv->initialized) {
+    return;
+  }
+
+  HAL_TIM_PWM_Stop(&drv->tim, TIM_CHANNEL_1);
+  HAL_TIM_PWM_Stop(&drv->tim, TIM_CHANNEL_2);
+  HAL_TIM_PWM_Stop(&drv->tim, TIM_CHANNEL_3);
+
+  HAL_TIM_Base_Stop(&drv->tim);
+
+  memset(drv, 0, sizeof(*drv));
+  drv->initialized = false;
+}
+
+void rgb_led_set_color(uint32_t color) {
+  rgb_led_t* drv = &g_rgb_led;
+  if (!drv->initialized) {
+    return;
+  }
+
+  TIM4->CCR1 = ((color >> 16) & 0xFF) * TIMER_PERIOD / 255;
+  TIM4->CCR2 = ((color >> 8) & 0xFF) * TIMER_PERIOD / 255;
+  TIM4->CCR3 = (color & 0xFF) * TIMER_PERIOD / 255;
+}
+
+#endif