Import of the watch repository from Pebble

src/fw/mfg/mfg_command.c

@@ -0,0 +1,194 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "mfg_command.h"
+
+#include "applib/app_launch_reason.h"
+#include "applib/app_watch_info.h"
+#include "console/prompt.h"
+#include "kernel/util/standby.h"
+#include "mfg/mfg_info.h"
+#include "process_management/app_install_manager.h"
+#include "process_management/app_manager.h"
+
+void command_enter_standby(void) {
+  enter_standby(RebootReasonCode_MfgShutdown);
+}
+
+void command_color_read(void) {
+  char buffer[10];
+  prompt_send_response_fmt(buffer, sizeof(buffer), "%d", mfg_info_get_watch_color());
+}
+
+void command_color_write(const char* color_num) {
+  char *end;
+  int color = strtol(color_num, &end, 10);
+
+  if (*end) {
+    prompt_send_response("Invalid color");
+    return;
+  }
+
+  mfg_info_set_watch_color(color);
+
+  const WatchInfoColor written_color = mfg_info_get_watch_color();
+  if (written_color == color) {
+    prompt_send_response("OK");
+  } else {
+    prompt_send_response("ERROR");
+  }
+}
+
+void command_disp_offset_read(void) {
+  char buffer[16];
+  prompt_send_response_fmt(buffer, sizeof(buffer), "X: %"PRId16" Y: %"PRId16,
+                           mfg_info_get_disp_offsets().x,
+                           mfg_info_get_disp_offsets().y);
+}
+
+void command_disp_offset_write(const char* offset_x_str, const char* offset_y_str) {
+  char *nonnumeric_x, *nonnumeric_y;
+  int8_t offset_x = strtol(offset_x_str, &nonnumeric_x, 10);
+  if (*nonnumeric_x) {
+    prompt_send_response("Invalid x offset");
+  }
+
+  int8_t offset_y = strtol(offset_y_str, &nonnumeric_y, 10);
+  if (*nonnumeric_y) {
+    prompt_send_response("Invalid y offset");
+  }
+
+  if (!*nonnumeric_x && !*nonnumeric_y) {
+    mfg_info_set_disp_offsets((GPoint) {offset_x, offset_y});
+  }
+}
+
+void command_rtcfreq_read(void) {
+  char buffer[10];
+  prompt_send_response_fmt(buffer, sizeof(buffer), "%"PRIu32, mfg_info_get_rtc_freq());
+}
+
+void command_rtcfreq_write(const char* rtc_freq_string) {
+  char *end;
+  uint32_t rtc_freq = strtol(rtc_freq_string, &end, 10);
+
+  if (*end) {
+    prompt_send_response("Invalid rtcfreq");
+    return;
+  }
+
+  mfg_info_set_rtc_freq(rtc_freq);
+}
+
+void command_model_read(void) {
+  char model_buffer[MFG_INFO_MODEL_STRING_LENGTH];
+  mfg_info_get_model(model_buffer);
+
+  // Just send it straight out, as it's already null-terminated
+  prompt_send_response(model_buffer);
+}
+
+void command_model_write(const char* model) {
+  // mfg_info_set_model will truncate if the string is too long, so no need to check
+  mfg_info_set_model(model);
+  char written_model[MFG_INFO_MODEL_STRING_LENGTH];
+  mfg_info_get_model(written_model);
+  if (!strncmp(model, written_model, MFG_INFO_MODEL_STRING_LENGTH)) {
+    prompt_send_response("OK");
+  } else {
+    prompt_send_response("ERROR");
+  }
+}
+
+#if BOOTLOADER_TEST_STAGE1
+#include "bootloader_test_bin.auto.h"
+
+#include "drivers/flash.h"
+#include "flash_region/flash_region.h"
+#include "system/firmware_storage.h"
+#include "system/bootbits.h"
+#include "system/logging.h"
+#include "system/reset.h"
+#include "util/crc32.h"
+#include "util/legacy_checksum.h"
+static void prv_bootloader_test_copy(uint32_t flash_addr, uint32_t flash_end) {
+  const uint8_t *bin;
+  size_t size;
+
+  bin = s_bootloader_test_stage2;
+  size = sizeof(s_bootloader_test_stage2);
+  flash_region_erase_optimal_range(flash_addr,
+                                   flash_addr,
+                                   flash_addr+size+sizeof(FirmwareDescription),
+                                   flash_end);
+
+  FirmwareDescription fw_desc = {
+    .description_length = sizeof(FirmwareDescription),
+    .firmware_length = size,
+    .checksum = 0,
+  };
+#if CAPABILITY_HAS_DEFECTIVE_FW_CRC
+  fw_desc.checksum = legacy_defective_checksum_memory(bin, size);
+#else
+  fw_desc.checksum = crc32(CRC32_INIT, bin, size);
+#endif
+
+  flash_write_bytes((uint8_t *)&fw_desc, flash_addr, sizeof(FirmwareDescription));
+  flash_write_bytes(bin, flash_addr+sizeof(FirmwareDescription), size);
+}
+
+#define BLTEST_LOG(x...) pbl_log(LOG_LEVEL_ALWAYS, __FILE__, __LINE__, x)
+
+void command_bootloader_test(const char *dest_type) {
+  prompt_command_finish();
+
+  BLTEST_LOG("BOOTLOADER TEST STAGE 1");
+  boot_bit_set(BOOT_BIT_FW_STABLE);
+
+  BLTEST_LOG("STAGE 1 -- Setting test boot bits");
+  boot_bit_clear(BOOT_BIT_BOOTLOADER_TEST_A | BOOT_BIT_BOOTLOADER_TEST_B);
+  boot_bit_set(BOOT_BIT_BOOTLOADER_TEST_A);
+
+  bool as_fw = true;
+  if (strcmp(dest_type, "prf") == 0) {
+    as_fw = false;
+  }
+  if (as_fw) {
+    BLTEST_LOG("STAGE 1 -- Copying STAGE 2 to scratch");
+    prv_bootloader_test_copy(FLASH_REGION_FIRMWARE_SCRATCH_BEGIN,
+                             FLASH_REGION_FIRMWARE_SCRATCH_END);
+
+    BLTEST_LOG("STAGE 1 -- Marking new FW boot bit");
+    boot_bit_set(BOOT_BIT_NEW_FW_AVAILABLE);
+  } else {
+    BLTEST_LOG("STAGE 1 -- Copying STAGE 2 to PRF");
+    flash_prf_set_protection(false);
+    prv_bootloader_test_copy(FLASH_REGION_SAFE_FIRMWARE_BEGIN, FLASH_REGION_SAFE_FIRMWARE_END);
+
+    BLTEST_LOG("STAGE 1 -- Marking PRF boot bit");
+    boot_bit_set(BOOT_BIT_FORCE_PRF);
+  }
+
+  BLTEST_LOG("STAGE 1 -- Rebooting");
+  RebootReason reason = { RebootReasonCode_PrfReset, 0 };
+  reboot_reason_set(&reason);
+  system_hard_reset();
+}
+#else
+void command_bootloader_test(void) {
+  prompt_send_response("Not configured for bootloader test");
+}
+#endif