• State TI Thinks Resolved
  • Replies 22 replies
  • Answers 1 answer
  • Subscribers 100 subscribers
  • Views 528 views
  • Users 0 members are here
Support feedback
Options
Options
Related

TDA4VH: Keywriter debug errors

Shabnam Ab
Prodigy 60 points

Part Number: AM69

I tried to provision my AM69 devkit and attempted to write 16 bytes to the OPT EXT fuses. On the first attempt, I received the error shown below. Based on this, it appeared that the optional fuses might not be supported.


OTP Keywriter ver: 10.1.4-v10.01.04a-1-gf7c27 (Fie
Legacy Boot Mode
OTP_VppEn
AM69 SK Detected!!
WKUP_GPIO0_VPP_CTRL output high
Key programming sequence initialted
Taking OTP certificate from 0x41c70004
Sciclient_otpProcessKeyCfg returns: -1
Debug response: 0x6e000000
Key programming sequence completed

I then modified the keywriter code to write only the required fuses and configuration data. However, for some reason, the serial port changes when I power-cycle the board, and I did not capture any logs. After turning the device off and back on and rerunning the process, I observed the error shown below.

OTP Keywriter ver: 10.1.4-v10.01.04a-1-gf7c27 (Fie
Legacy Boot Mode
OTP_VppEn
AM69 SK Detected!!
WKUP_GPIO0_VPP_CTRL output high
Key programming sequence initialted
Taking OTP certificate from 0x41c70004
Sciclient_otpProcessKeyCfg returns: -1
Debug response: 0x4e000800
Key programming sequence completed

From the keywriter logs and docs, it looks to me that the key fuses may have been burned successfull but I am gettign errors for trying to overwrite them. I tried to boot an unsigned image, but I get no serial output. Is it expected to see no serial logs when running unsigned images? Should I try booting a signed image to validate the provisioning flow? Is there any reliable way to rerun keywriter or verify that the fuses were programmed correctly?

Thanks

Shabnam

  • 0
    Prodigy 60 points

    This is the original command that I ran:

    ./gen_keywr_cert.sh -t ti_fek_public.pem -s keys/smpk.pem --smek keys/smek.key -b keys/bmpk.pem --bmek keys/bmek.key --keycnt 2 --keyrev 1 --msv 0x1 --sr-sbl 1 --sr-sysfw 1 --sr-bcfg 1 --ext-otp ext_otp_data.bin --ext-otp-indx 0
    --ext-otp-size 128

    I have removed -ext-opt-field, which can remain unfused.

    Can I assume that --sr-sbl, --sr-sysfw, and --sr-bcfg are already set to 1 and therefore do not need to be written again? If I try to write them again, I will get error?

    Also, should I assume that in case of any error, keyrev will not be written and the device will not transition to HS-SE, even if the keys have already been written successfully?

    Thanks

    Shabnam



  • 0 in reply to Shabnam Ab
    TI__Guru 63625 points

    Hi Shabnam,

    Do we have TIFS traces for both of the trials? Also which keywriter package version you are using?

    Regards
    Diwakar

  • 0 in reply to Diwakar Dhyani
    Prodigy 60 points

    I did not get any trace. It's OTP Keywriter ver: 10.1.4-v10.01.04a-1-gf7c27 .


  • 0 in reply to Shabnam Ab
    Prodigy 60 points

    I tried to program a second board with only primary and backup keys based on the readme file in the keywriter.


    ./gen_keywr_cert.sh \
    -t ti_fek_public.pem \
    -s keys/smpk.pem --smek keys/smek.key -s-rp --smek-rp \
    -b keys/bmpk.pem --bmek keys/bmek.key -b-rp --bmek-rp \
    --mek-opt 0x1 --mpk-opt 0x21 \
    --keycnt 2 --keycnt-wp \
    --keyrev 1 \

    I see this error:

    OTP Keywriter ver: 10.1.4-v10.01.04a-1-gf7c27 (Fie

    Legacy Boot Mode

    OTP_VppEn

    AM69 SK Detected!!

    WKUP_GPIO0_VPP_CTRL output high

    Key programming sequence initialted

    Taking OTP certificate from 0x41c70004

    Sciclient_otpProcessKeyCfg returns: -1

    Debug response: 0x800

    Key programming sequence completed

    Can it be related to my power supply? If yes, can I fix it and provision the board successfully?

  • 0 in reply to Shabnam Ab
    TI__Guru 63625 points

    Hi Shabnam,

    Shabnam Ab said:
    I did not get any trace

    Please check the Wakeup UART for TIFS traces. The logs you provided are from the R5 application, but we need the TIFS-level logs to see exactly what happened during the eFuse write operation inside TIFS.

    Shabnam Ab said:
    Can it be related to my power supply? If yes, can I fix it and provision the board successfully?

    Before attempting full key programming, let's verify the eFuse write operation is working correctly by programming only the MSV value with override flag on a fresh board. This approach ensures we don't risk losing another board if something goes wrong during the write process.Since we already ran multiple test on the current board its better we choose fresh board to avoid any confusion.

    Please use the following command to generate a keywriter image that only programs the MSV value:

    ./gen_keywr_cert.sh --msv 0xC0FFE --msv-ovrd -t ti_fek_public.pem

    Share the results after running the keywriter image. Also would like to know if you are running the tool on custom board or on EVM ?

    Regards
    Diwakar

  • 0 in reply to Diwakar Dhyani
    Prodigy 60 points

    I had all ports open, I did not see any logs.

    I have tested writing the MSV. On the first attempt, I observed abnormal logging behavior like keywriter  is getting reset, no debug success message was emitted, and logging stopped unexpectedly.


    On the second attempt, I received a programming error for MSV, which is expected without explicitly enabling override.

    First log:

    ort /dev/ttyUSB1, 17:04:34 [U]

    Press CTRL-A Z for help on special keys
                                                                                                       
    OTP Keywriter Version: 02.00.00.00 (Feb 13 2026 - 20:37:42)                                        
                                                                                                       
     OTP Keywriter ver: 10.1.4-v10OTP Keywriter Version: 02.00.00.00 (Feb 13 2026 - 20:37:42)          
                                                                                                       
     OTP KOTP Keywriter Version: 02.00.00.00 (Feb 13 2026 - 20:37:42)

     OTP KOTP Keywriter Version: 02.00.00.00 (Feb 13 2026 - 20:37:42)

     OTP KOTP Keywriter Version: 02.00.00.00 (Feb 13 2026 - 20:37:42)

     OTP OTP Keywriter Version: 02.00.00.00 (Feb 13 2026 - 20:37:42)

     OTP KOTP Keywriter Version: 02.00.00.00 (Feb 13 2026 - 20:37:42)

     OTP Keywriter ver: OTP Keywriter Version: 02.00.00.00 (Feb 13 2026 - 20:37:42)

     OTP Keywriter ver: 10.1.4-v10.01.04a-1-gf7c27 (Fie
    Legacy Boot Mode
    OTP_VppEn
    OTP Keywriter Version: 02.00.00.00 (Feb 13 2026 - 20:37:42)

     OTP Keywriter ver: 10.1.4-v10.01.04a-1-gf7c27 (Fie
    Legacy Boot Mode
    OTP_VppEn
    OTP Keywriter Version: 02.00.00.00 (Feb 13 2026 - 20:37:42)

     OTP KOTP Keywriter Version: 02.00.00.00 (Feb 13 2026 - 20:37:42)

     

    Second log: 


    OTP Keywriter Version: 02.00.00.00 (Feb 13 2026 - 20:37:42)
    OTP Keywriter ver: 10.1.4-v10.01.04a-1-gf7c27 (Fie
    Legacy Boot Mode
    OTP_VppEn
    AM69 SK Detected!!
    WKUP_GPIO0_VPP_CTRL output high
    Key programming sequence initialted
    Taking OTP certificate from 0x41c70004
    Sciclient_otpProcessKeyCfg returns: -1
    Debug response: 0x2000000
    Key programming sequence completed

  • 0 in reply to Shabnam Ab
    TI__Guru 63625 points

    Hi Shabnam,

    Shabnam Ab said:
    I had all ports open, I did not see any logs.
    No logs on com port 1 (ttyUSB0) ? 
    Regards
    Diwakar
  • 0 in reply to Diwakar Dhyani
    Prodigy 60 points

    No. I am using the dev kit.

  • 0 in reply to Shabnam Ab
    TI__Guru 63625 points

    Hi 

    Allow me sometime to test the same at my end. While i am preparing the setup , share complete details on how you generated the keywriter image. So that can cross verify and try the same at my end.

    Regards
    Diwakar

  • 0 in reply to Diwakar Dhyani
    Prodigy 60 points

    I can share the full code by email if needed. I can also test your setup with my board. The mains steps are:

    1- Copying keywriter files into the RTOS SDK for building the app:

    copy_files_to_sdk() {
    log_step "COPYING FILES TO SDK"

    local TIFS_DIR="${PDK_DIR}/packages/ti/boot/keywriter/tifs_bin/j784s4"
    local SOC_DIR="${PDK_DIR}/packages/ti/boot/keywriter/soc/j784s4"
    local SCRIPTS_DIR="${PDK_DIR}/packages/ti/boot/keywriter/scripts"
    local KEYS_OUT_DIR="${SCRIPTS_DIR}/keys"

    mkdir -p "${TIFS_DIR}" "${SOC_DIR}" "${SCRIPTS_DIR}" "${KEYS_OUT_DIR}"

    cp "${BIN_DIR}/ti-fs-keywriter.bin" "${TIFS_DIR}/"
    cp "${BIN_DIR}/ti-fs-firmware-hs-fs-cert.bin" "${TIFS_DIR}/"
    cp "${BIN_DIR}/ti-fs-firmware-hs-fs-enc.bin" "${TIFS_DIR}/"
    cp "${BIN_DIR}/combined-tifs-cfg.bin" "${TIFS_DIR}/"
    log_success "Copied TIFS binaries"

    cp "${BIN_DIR}/tifs_keywriter.h" "${SOC_DIR}/"
    log_success "Copied header"

    cp "${FEK_PUBLIC}" "${SCRIPTS_DIR}/ti_fek_public.pem"
    log_success "Copied FEK public key"

    cp "${SMPK_PATH}" "${KEYS_OUT_DIR}/smpk.pem"
    cp "${BMPK_PATH}" "${KEYS_OUT_DIR}/bmpk.pem"
    cp "${SMEK_PATH}" "${KEYS_OUT_DIR}/smek.key"
    cp "${BMEK_PATH}" "${KEYS_OUT_DIR}/bmek.key"
    local key_files=(
    "${KEYS_OUT_DIR}/smpk.pem"
    "${KEYS_OUT_DIR}/bmpk.pem"
    "${KEYS_OUT_DIR}/smek.key"
    "${KEYS_OUT_DIR}/bmek.key"
    )
    chmod 600 "${key_files[@]}"
    log_success "Copied customer keys"
    }

    2- Building the key write app in single stage (I only tested with legacy mode: the build generates tiboot and tifs):

    build_single_stage() {
    if [[ "${WITH_METADATA_FUSES}" == "1" ]]; then
    log_step "SINGLE STAGE: Signing + Encryption Keys + MSV + SWREV + KEYCNT=2 + KEYREV=1"
    else
    log_step "SINGLE STAGE: Signing + Encryption Keys + KEYCNT=2 + KEYREV=1"
    fi

    local STAGE_OUTPUT="${OUTPUT_DIR}/stage1"
    mkdir -p "${STAGE_OUTPUT}/certificates"
    local cert_log="${STAGE_OUTPUT}/cert_generation.log"

    local SCRIPTS_DIR="${PDK_DIR}/packages/ti/boot/keywriter/scripts"
    local X509_DIR="${PDK_DIR}/packages/ti/boot/keywriter/x509cert"

    # Clean previous certificates
    rm -f "${X509_DIR}/final_certificate.bin" "${SCRIPTS_DIR}/primary_cert.bin" \
    "${SCRIPTS_DIR}/secondary_cert.bin" "${SCRIPTS_DIR}/verify_hash.csv"

    local script_name="gen_keywr_cert.sh"
    local cert_cmd=(
    "./${script_name}"
    -t ti_fek_public.pem
    -s keys/smpk.pem
    --smek keys/smek.key
    -s-rp
    --smek-rp
    -b keys/bmpk.pem
    --bmek keys/bmek.key
    -b-rp
    --bmek-rp
    --mek-opt 0x1
    --mpk-opt 0x21
    )
    cert_cmd+=(
    --keycnt 2
    --keycnt-wp
    --keyrev 1
    )
    if [[ "${WITH_METADATA_FUSES}" == "1" ]]; then
    cert_cmd+=(
    --msv "${MSV}"
    --sr-sbl "${SWREV_SBL}"
    --sr-sysfw "${SWREV_SYSFW}"
    --sr-bcfg "${SWREV_BOARDCFG}"
    )
    fi

    echo ""
    echo " Single-Stage Configuration:"
    echo " ┌─────────────────────────────────────────────────────────┐"
    echo " │ KEYS: SMPK/SMEK + BMPK/BMEK │"
    echo " │ KEYCNT: 2 KEYREV: 1 (HS-SE) │"
    echo " ├─────────────────────────────────────────────────────────┤"
    if [[ "${WITH_METADATA_FUSES}" == "1" ]]; then
    echo " │ MSV: ${MSV}"
    echo " │ SWREV_SBL: ${SWREV_SBL} SWREV_SYSFW: ${SWREV_SYSFW} SWREV_BOARDCFG: ${SWREV_BOARDCFG}"
    else
    echo " │ MSV/SWREV: SKIPPED"
    fi
    echo " ├─────────────────────────────────────────────────────────┤"
    echo " │ Certificate: Dual-signed (SMPK + BMPK) │"
    echo " └─────────────────────────────────────────────────────────┘"
    echo ""

    log_info "Running: ${cert_cmd[*]}"
    pushd "${SCRIPTS_DIR}" >/dev/null
    if ! "${cert_cmd[@]}" 2>&1 | tee "${cert_log}"; then
    popd >/dev/null
    die "Certificate generation command failed"
    fi
    popd >/dev/null

    if grep -Eqi 'bad decrypt|wrong final block length|error:[0-9A-Fa-f]+' "${cert_log}"; then
    die "OpenSSL errors detected during certificate generation (see ${cert_log})"
    fi

    local cert_file="${X509_DIR}/final_certificate.bin"
    [[ ! -f "${cert_file}" ]] && die "Single-stage certificate generation FAILED"

    local secondary_cert="${SCRIPTS_DIR}/secondary_cert.bin"
    [[ ! -s "${secondary_cert}" ]] && die "Single-stage did not generate secondary_cert.bin; ensure BMPK/BMEK are present."

    check_cert_size "${SCRIPTS_DIR}/primary_cert.bin" "Single-stage primary_cert.bin"
    check_cert_size "${secondary_cert}" "Single-stage secondary_cert.bin"

    # Build keywriter
    build_keywriter

    # Collect outputs
    cp "${KW_IMG}" "${STAGE_OUTPUT}/tiboot3.bin"
    if [[ "${BOOT_MODE}" == "legacy" ]]; then
    cp "${PDK_DIR}/packages/ti/boot/keywriter/tifs_bin/j784s4/ti-fs-keywriter.bin" "${STAGE_OUTPUT}/tifs.bin"
    fi
    cp "${cert_file}" "${STAGE_OUTPUT}/certificates/"
    cp "${SCRIPTS_DIR}/primary_cert.bin" "${STAGE_OUTPUT}/certificates/" 2>/dev/null || true
    cp "${secondary_cert}" "${STAGE_OUTPUT}/certificates/" 2>/dev/null || true
    [[ -f "${SCRIPTS_DIR}/verify_hash.csv" ]] && cp "${SCRIPTS_DIR}/verify_hash.csv" "${STAGE_OUTPUT}/certificates/"

    log_success "Single stage complete: ${STAGE_OUTPUT}/"
    log_warn "Single-stage sets KEYREV=1 - Device becomes HS-SE (PERMANENT)!"
    }
    And here is the build_keywriter functions:
    build_keywriter() {
    log_info "Building keywriter binary..."

    local BUILD_DIR="${PDK_DIR}/packages/ti/build"

    if [[ -n "${TOOLCHAIN_PATH_R5:-}" ]]; then
    if [[ ! -x "${TOOLCHAIN_PATH_R5}/bin/tiarmclang" ]]; then
    die "TOOLCHAIN_PATH_R5 set but tiarmclang not found"
    fi
    log_info "Using TOOLCHAIN_PATH_R5: ${TOOLCHAIN_PATH_R5}"
    else
    local cgt_dir
    cgt_dir="$(find "${SDK_DIR}" -maxdepth 1 -type d -name "ti-cgt-armllvm_*" 2>/dev/null | head -1 || true)"
    if [[ -n "${cgt_dir}" && -x "${cgt_dir}/bin/tiarmclang" ]]; then
    TOOLCHAIN_PATH_R5="${cgt_dir}"
    export TOOLCHAIN_PATH_R5
    log_info "Using TOOLCHAIN_PATH_R5: ${TOOLCHAIN_PATH_R5}"
    fi
    fi

    [[ -z "${TOOLCHAIN_PATH_R5:-}" ]] && die "TI ARM CGT (tiarmclang) not found"

    export PSDKR_PATH="${SDK_DIR}"
    export PDK_INSTALL_PATH="${PDK_DIR}/packages"

    pushd "${BUILD_DIR}" >/dev/null

    local make_args=()
    [[ -n "${GCC_ARMCOMPILER:-}" ]] && make_args+=(GCC_ARMCOMPILER="${GCC_ARMCOMPILER}")
    [[ -n "${TOOLCHAIN_PATH_GCC:-}" ]] && make_args+=(TOOLCHAIN_PATH_GCC="${TOOLCHAIN_PATH_GCC}")
    [[ -n "${TOOLCHAIN_PATH_GCC_ARCH64:-}" ]] && make_args+=(TOOLCHAIN_PATH_GCC_ARCH64="${TOOLCHAIN_PATH_GCC_ARCH64}")
    [[ -n "${GCC_ARCH64_BIN_PREFIX:-}" ]] && make_args+=(GCC_ARCH64_BIN_PREFIX="${GCC_ARCH64_BIN_PREFIX}")
    [[ -n "${TOOLCHAIN_PATH_R5:-}" ]] && make_args+=(TOOLCHAIN_PATH_R5="${TOOLCHAIN_PATH_R5}")

    if [[ "${BOOT_MODE}" == "combined" ]]; then
    make "${make_args[@]}" keywriter_img_combined_clean BOARD=j784s4_evm 2>/dev/null || true
    make "${make_args[@]}" keywriter_img_combined BOARD=j784s4_evm -j"$(nproc 2>/dev/null || echo 4)"
    KW_IMG="${PDK_DIR}/packages/ti/boot/keywriter/binary/j784s4/keywriter_img_combined_j784s4_release.tiimage"
    else
    make "${make_args[@]}" keywriter_img_clean BOARD=j784s4_evm 2>/dev/null || true
    make "${make_args[@]}" keywriter_img BOARD=j784s4_evm -j"$(nproc 2>/dev/null || echo 4)"
    KW_IMG="${PDK_DIR}/packages/ti/boot/keywriter/binary/j784s4/keywriter_img_j784s4_release.tiimage"
    fi

    popd >/dev/null

    [[ ! -f "${KW_IMG}" ]] && die "Build FAILED - keywriter image not found"

    local img_size
    img_size=$(stat -c%s "${KW_IMG}" 2>/dev/null || stat -f%z "${KW_IMG}" 2>/dev/null)
    log_success "Build successful: $(basename "${KW_IMG}") (${img_size} bytes)"
    }
  • 0 in reply to Shabnam Ab
    Prodigy 60 points

    I ran another experiment (making keycnt 2)--the same programming error but I got logs on the first UART port as well.

    Keywriter log:

    OTP Keywriter Version: 02.00.00.00 (Feb 17 2026 - 04:46:20)

     OTP Keywriter ver: 10.1.4-v10.01.04a-1-gf7c27 (Fie
    Legacy Boot Mode
    OTP_VppEn
    AM69 SK Detected!!
    WKUP_GPIO0_VPP_CTRL output high
    Key programming sequence initialted                                                                 
    Taking OTP certificate from 0x41c70004                                                              
    Sciclient_otpProcessKeyCfg returns: -1                                                              
    Debug response: 0x2000                                                                              
    Key programming sequence completed 

    Fist port log:

    Welcome to minicom 2.10

    OPTIONS: I18n
    Port /dev/ttyUSB0, 20:27:23 [U]

    Press CTRL-A Z for help on special keys

    0x400002
            0xC00004
                    0x4003007
                             0x4400A14
                                      0x40000B
                                              0xC00004
                                                      0x4003007
                                                               0x4400A14
                                                                        0x40000D
                                                                                0xC00004
                                                                                        0x20800000
                                                                                                  0x20800001
                                                                                                            0x400002
                                                                                                                    0xC00004
                                                                                                                            0x4003007
                                                                                                                                     0x4400A14
                                                                                                                                              0x400002
                                                                                                                                                      0xC00004
                                                                                                                                                              0x4003007
                                                                                                                                                                       0x444
                                                                                                                                                                           1
                                                                                                                                                                           4
                                                                                                                                                                           #
                                                                                                                                                                           .
                                                                                                                                                                           #
                                                                                                                                                                           0
                                                                                                                                                                           0
                                                                                                                                                                           0
                                                                                                                                                                           0
                                                                                                                                                                           0
                                                                                                                                                                           d
                                                                                                                                                                           d
                                                                                                                                                                           d
                                                                                                                                                                           d

                                                                                                                                                                           d

                                                                                                                                                                           0

                                                                                                                                                                           d

                                                                                                                                                                           d

                                                                                                                                                                           d

                                                                                                                                                                           0

                                                                                                                                                                           #
                                                                                                                                                                           .
                                                                                                                                                                           #

                                                                                                                                                                           
                                                                                                                                                                           0
                                                                                                                                                                           d
                                                                                                                                                                           0

                                                                                                                                                                           
                                                                                                                                                                           0
                                                                                                                                                                           d
                                                                                                                                                                           0

                                                                                                                                                                           
                                                                                                                                                                           1
                                                                                                                                                                           1
                                                                                                                                                                           d
                                                                                                                                                                           1
                                                                                                                                                                           1

                                                                                                                                                                           
                                                                                                                                                                           1
                                                                                                                                                                           d
                                                                                                                                                                           1

                                                                                                                                                                           
                                                                                                                                                                           d

                                                                                                                                                                           
                                                                                                                                                                           d
                                                                                                                                                                           d

                                                                                                                                                                           
                                                                                                                                                                           d
                                                                                                                                                                           d

                                                                                                                                                                           
                                                                                                                                                                           0
                                                                                                                                                                           T
                                                                                                                                                                           0
                                                                                                                                                                           0

                                                                                                                                                                           
                                                                                                                                                                           0
                                                                                                                                                                           d
                                                                                                                                                                           0

  • 0 in reply to Shabnam Ab
    TI__Guru 63625 points

    Hi  

    I need to delete your post as i t was causing issue , i was unable to reply to the post.

    The issue seems to be related to pinmux, same is there in SK-EVM as well. I attached quick fix also , i will debug further and will add proper fix also.

    diff --git a/ti/boot/keywriter/soc/j784s4/keywriter_utils.c b/ti/boot/keywriter/soc/j784s4/keywriter_utils.c
index f57163c..b2d970a 100644
--- a/ti/boot/keywriter/soc/j784s4/keywriter_utils.c
+++ b/ti/boot/keywriter/soc/j784s4/keywriter_utils.c
@@ -50,7 +50,7 @@
 #include <ti/drv/uart/UART_stdio.h>
 #include <ti/drv/gpio/GPIO.h>
 #include <ti/drv/gpio/soc/GPIO_soc.h>
-
+#define KEYWRITER_SK_VPP_CTRL_GPIO       (28U)
 GPIO_PinConfig gpioPinConfigs[] = {
     EN_EFUSE_VPP_CTRL | GPIO_CFG_OUTPUT,
     SK_EN_EFUSE_VPP_CTRL | GPIO_CFG_OUTPUT
@@ -71,6 +71,23 @@ GPIO_v0_Config GPIO_v0_config = {
     0,
 };
 
+/* Enable VPP for AM69 SK board */
+static void OTP_VppEn_SK(void)
+{
+    uint32_t regVal;
+
+    UART_printf("OTP_VppEn_SK\n");
+
+    /* Set the GPIO direction to output */
+    regVal = (HW_RD_REG32(0x42110010)) & (~(0x1 << KEYWRITER_SK_VPP_CTRL_GPIO));
+    HW_WR_REG32(0x42110010, regVal);
+
+    /* Set the GPIO value to high */
+    regVal = (HW_RD_REG32(0x42110014)) | (0x1 << KEYWRITER_SK_VPP_CTRL_GPIO);
+    HW_WR_REG32(0x42110014, regVal);
+
+    UART_printf("OTP Vpp is Enabled!\n");
+}  
 void OTP_VppEn(void)
 {
     Board_initCfg      boardCfg;
@@ -102,6 +119,7 @@ void OTP_VppEn(void)
         {
             UART_printf("AM69 SK Detected!!\n");
             gpioIndex = UTRUE;
+                       OTP_VppEn_SK();
         }
     }

    Logs from SK board after above changes.

    Regards
    Diwakar

  • 0 in reply to Diwakar Dhyani
    Prodigy 60 points

    Thanks so much Diwakar. I tested MSV programming with the patch and received a successful debug report.

    I’d like to proceed with key provisioning and enabling secure boot on the board. Please continue sharing your status and confirm whether it’s safe to move forward, thanks.

  • 0 in reply to Shabnam Ab
    TI__Guru 63625 points

    Hi Shabnam,

    There is a bug in the code we need to pass port number instead of gpio index while calling GPIO_socGetInitCfg and GPIO_socSetInitCfg.
    It has to be 0 , here is the corrected code.
        /* Initialize pinmux */
     boardCfg = BOARD_INIT_PINMUX_CONFIG |
@@ -102,18 +103,17 @@ void OTP_VppEn(void)
         {
             UART_printf("AM69 SK Detected!!\n");
             gpioIndex = UTRUE;
+
         }
     }
 
     /* Configure GPIO base address */
     GPIO_v0_HwAttrs gpioCfg;
-    GPIO_socGetInitCfg(gpioIndex, &gpioCfg);
+    GPIO_socGetInitCfg(0, &gpioCfg);
     gpioCfg.baseAddr = CSL_WKUP_GPIO0_BASE;
-    GPIO_socSetInitCfg(gpioIndex, &gpioCfg);
-
+    GPIO_socSetInitCfg(0, &gpioCfg);
     /* Set GPIO to HIGH */
     GPIO_init();
     GPIO_write(gpioIndex, 1);  
     UART_printf("WKUP_GPIO0_VPP_CTRL output high\n");
 }
    Regards
    Diwakar
  • 0 in reply to Diwakar Dhyani
    Prodigy 60 points
    Hi Diwakar

    Thanks so much for debuting the issue. With the current bug fix, I was able to provision the devkit, burn the fuses, and enable secure boot.
    I need TI’s input on the following points to close this ticket:
    1. What are the implications of this bug on GPIO programming? If the board is used for bare-metal applications, should we expect additional issues when accessing or configuring GPIO registers?
    2. We have a custom board based on the standard AM69 IC (P/N AM6958ATGGHAALY) . On that board, we were unable to burn fuses and observed similar behavior. Please advise whether this is likely a hardware issue, or if a different RTOS/Keywriter release is required.
    Please let me know your assessment, thanks. 
  • 0 in reply to Shabnam Ab
    TI__Guru 63625 points

    Hi Shabnam,

    Shabnam Ab said:
    Thanks so much for debuting the issue. With the current bug fix, I was able to provision the devkit, burn the fuses, and enable secure boot.

    Great to hear that.

    Shabnam Ab said:
    What are the implications of this bug on GPIO programming? If the board is used for bare-metal applications, should we expect additional issues when accessing or configuring GPIO registers?

    The issue was we were feeding wrong value to the wrapper api. But if you are going to use direct register, write i don't see any issue.

    Shabnam Ab said:
    We have a custom board based on the standard AM69 IC (P/N AM6958ATGGHAALY) . On that board, we were unable to burn fuses and observed similar behavior. Please advise whether this is likely a hardware issue, or if a different RTOS/Keywriter release is required.

    Custom hardware doesn't require to have separate key writer release. I assume carl already pointed out the issue earlier, that VPP is not getting enabled in the custom board as well.

    Regards
    Diwakar

  • 0 in reply to Diwakar Dhyani
    Prodigy 60 points

    Hi Diwakar, We tested on the custom board with the patch as well. If the VPP is not the issue, can I assume P/N AM6958ATGGHAALY is a general purpose IC and it cannot be fused?

  • 0 in reply to Shabnam Ab
    TI__Guru 63625 points

    Hi Shabnam,

    Are you using same GPIO as of EVM on your custom board to enable the VPP ? Device seems to be secure to me 

    You can follow this FAQ to check the device type.

    Regards
    Diwakar

  • 0 in reply to Diwakar Dhyani
    Prodigy 60 points

    Hi Diwakar, 

    Is there any difference between small y vs capital Y?
    For this part, should I assume we can use any J7x  keywriter release? 

  • 0 in reply to Shabnam Ab
    TI__Guru 63625 points

    Hi Shabnam,

    Shabnam Ab said:
    Is there any difference between small y vs capital Y?

    What do you mean by that?

    Shabnam Ab said:
    For this part, should I assume we can use any J7x  keywriter release? 

    No, You have to specifically use j784s4 based keywriter releases for AM69 HS devices.

    Regards
    Diwakar 

  • 0 in reply to Diwakar Dhyani
    Prodigy 60 points

    The field parameter show Y vs y in the first column. 

  • 0 in reply to Shabnam Ab
    TI__Guru 63625 points

    One is functional safety parameter another is security .