/*
|
* Copyright (c) 2019-2023 Beijing Hanwei Innovation Technology Ltd. Co. and
|
* its subsidiaries and affiliates (collectly called MKSEMI).
|
*
|
* All rights reserved.
|
*
|
* Redistribution and use in source and binary forms, with or without
|
* modification, are permitted provided that the following conditions are met:
|
*
|
* 1. Redistributions of source code must retain the above copyright notice,
|
* this list of conditions and the following disclaimer.
|
*
|
* 2. Redistributions in binary form, except as embedded into an MKSEMI
|
* integrated circuit in a product or a software update for such product,
|
* must reproduce the above copyright notice, this list of conditions and
|
* the following disclaimer in the documentation and/or other materials
|
* provided with the distribution.
|
*
|
* 3. Neither the name of MKSEMI nor the names of its contributors may be used
|
* to endorse or promote products derived from this software without
|
* specific prior written permission.
|
*
|
* 4. This software, with or without modification, must only be used with a
|
* MKSEMI integrated circuit.
|
*
|
* 5. Any software provided in binary form under this license must not be
|
* reverse engineered, decompiled, modified and/or disassembled.
|
*
|
* THIS SOFTWARE IS PROVIDED BY MKSEMI "AS IS" AND ANY EXPRESS OR IMPLIED
|
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
* MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
* DISCLAIMED. IN NO EVENT SHALL MKSEMI OR CONTRIBUTORS BE LIABLE FOR ANY
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
*/
|
|
#include <stdio.h>
|
#include <stdlib.h>
|
#include <stddef.h>
|
#include <stdarg.h>
|
#include <errno.h>
|
#include <string.h>
|
#include <ctype.h>
|
#include <stdint.h>
|
#include "se_api.h"
|
#include "mk_trace.h"
|
#include "uart_in_spi.h"
|
#include "mk_gpio.h"
|
#include "mk_spi.h"
|
|
#define SE_PRINT_DEBUG (0)
|
|
#if SE_PRINT_DEBUG == 1
|
#include "mk_uwb.h"
|
#include "RTTDEBUG.h"
|
#endif
|
|
static uint8_t g_uart_data[1024];
|
|
uint16_t passthrough_apdu_to_t1(uint8_t *cmd_buf, uint16_t cmd_len, uint32_t *resp_buf_addr, uint16_t *resp_len)
|
{
|
SE_data cmd_apdu;
|
SE_data rsp_apdu;
|
ESESTATUS status = ESESTATUS_FAILED;
|
|
// memset(&cmd_apdu, 0x00, sizeof(SE_data));
|
// memset(&rsp_apdu, 0x00, sizeof(SE_data));
|
|
cmd_apdu.p_data = cmd_buf;
|
cmd_apdu.len = cmd_len;
|
status = se_transmit_receive(&cmd_apdu, &rsp_apdu);
|
|
if (status == ESESTATUS_SUCCESS)
|
{
|
if (rsp_apdu.len > 0)
|
{
|
int i = 0;
|
LOG_INFO(TRACE_MODULE_SE, "[TX][%d]", rsp_apdu.len);
|
while (i < rsp_apdu.len)
|
{
|
LOG_INFO(TRACE_NO_OPTION | TRACE_MODULE_SE, "%02X", rsp_apdu.p_data[i]);
|
i++;
|
}
|
LOG_INFO(TRACE_NO_OPTION | TRACE_MODULE_SE, "\r\n");
|
}
|
|
*resp_buf_addr = (uint32_t)rsp_apdu.p_data;
|
*resp_len = rsp_apdu.len;
|
}
|
else
|
{
|
LOG_INFO(TRACE_MODULE_SE, "response status=%d\r\n", status);
|
}
|
return (uint16_t)status;
|
}
|
|
static void __NO_RETURN cmd_from_uart_to_t1(void)
|
{
|
int len;
|
uint32_t resp_addr;
|
uint16_t resp_len;
|
uint8_t *p_data;
|
|
#if SE_PRINT_DEBUG == 1
|
uint32_t timer1, timer2;
|
uint8_t ins;
|
#endif
|
|
while (1)
|
{
|
do
|
{
|
// memset(g_uart_data, 0, sizeof(g_uart_data));
|
|
len = uart_receive_in_spi(g_uart_data, (uint16_t)sizeof(g_uart_data), NULL);
|
if (len >= 5)
|
{
|
break;
|
}
|
} while (1);
|
|
#if SE_PRINT_DEBUG == 1
|
timer1 = phy_timer_count_get();
|
ins = g_uart_data[1];
|
#endif
|
|
passthrough_apdu_to_t1(g_uart_data, (uint16_t)len, &resp_addr, (uint16_t *)&resp_len);
|
p_data = (uint8_t *)resp_addr;
|
|
#if SE_PRINT_DEBUG == 1
|
timer2 = phy_timer_count_get();
|
SEGGER_RTT_printf(0, "T %u, ins = %02x\r\n", PHY_TIMER_COUNT_TO_MS(timer2 - timer1), ins);
|
#endif
|
|
do
|
{
|
if (uart_send_in_spi(p_data, resp_len, NULL) == DRV_OK)
|
{
|
break;
|
}
|
} while (1);
|
};
|
}
|
|
int tm_main(void)
|
{
|
if (se_init(ESE_MODE_NORMAL) != ESESTATUS_SUCCESS)
|
{
|
return 0;
|
}
|
|
uart_in_spi_init();
|
|
#if SE_PRINT_DEBUG == 1
|
RTTInit();
|
#endif
|
|
// SEGGER_RTT_printf(0,"\n\rinstall applet\n\r");
|
cmd_from_uart_to_t1();
|
|
// se_deinit ();
|
|
// return 1;
|
}
|
|
uint16_t transmit_only_apdu_to_t1(uint8_t *cmd_buf, uint16_t cmd_len)
|
{
|
SE_data cmd_apdu;
|
ESESTATUS status = ESESTATUS_FAILED;
|
|
// memset(&cmd_apdu, 0x00, sizeof(SE_data));
|
|
cmd_apdu.p_data = cmd_buf;
|
cmd_apdu.len = cmd_len;
|
status = se_transmit_only(&cmd_apdu);
|
|
if (status == ESESTATUS_SUCCESS)
|
{
|
}
|
else
|
{
|
LOG_INFO(TRACE_MODULE_SE, "response status=%d\r\n", status);
|
}
|
return (uint16_t)status;
|
}
|
|
uint16_t receive_only_resp_from_t1(uint32_t *resp_buf_addr, uint16_t *resp_len)
|
{
|
SE_data rsp_apdu;
|
ESESTATUS status = ESESTATUS_FAILED;
|
|
status = se_receive_only(&rsp_apdu);
|
|
/*
|
if (status == ESESTATUS_NO_DATA_TO_RECEIVE)
|
{
|
|
}
|
else */
|
if (status == ESESTATUS_SUCCESS)
|
{
|
*resp_buf_addr = (uint32_t)rsp_apdu.p_data;
|
*resp_len = rsp_apdu.len;
|
}
|
else
|
{
|
// LOG_INFO(TRACE_MODULE_SE, "response status=%d\r\n", status);
|
}
|
return (uint16_t)status;
|
}
|
|
uint8_t uwbs_check_se(uint8_t *p_des_data, uint8_t *p_des_len);
|
uint8_t uwbs_check_se(uint8_t *p_des_data, uint8_t *p_des_len)
|
{
|
struct SPI_CFG_T usr_spi_cfg = {
|
.bit_rate = 1000000,
|
.data_bits = 8,
|
.slave = 0,
|
.clk_phase = 0,
|
.clk_polarity = 0,
|
.ti_mode = 0,
|
.dma_rx = false,
|
.dma_tx = false,
|
.int_rx = false,
|
.int_tx = false,
|
};
|
// get default AID from SE
|
SE_data cmd_apdu = {
|
.p_data = (uint8_t[]){0x00, 0xA4, 0x04, 0x00, 0x00},
|
.len = 5,
|
};
|
SE_data rsp_apdu;
|
uint8_t ret = DRV_OK;
|
|
if (NULL == p_des_data || NULL == p_des_len)
|
{
|
LOG_ERROR(TRACE_MODULE_SE, "%s: input error!\r\n", __FUNCTION__);
|
*p_des_len = 1;
|
return DRV_ERROR;
|
}
|
// memset(&rsp_apdu, 0, sizeof(rsp_apdu));
|
if (DRV_OK != (uint8_t)spi_open(SPI_ID1, &usr_spi_cfg))
|
{
|
LOG_ERROR(TRACE_MODULE_SE, "%s: spi open error!\r\n", __FUNCTION__);
|
*p_des_len = 1;
|
return DRV_ERROR;
|
}
|
gpio_pin_set_dir(IO_PIN_8, GPIO_DIR_OUT, 1);
|
ESESTATUS status = se_init(ESE_MODE_NORMAL);
|
if (status != ESESTATUS_SUCCESS)
|
{
|
ret = (uint8_t)status;
|
LOG_ERROR(TRACE_MODULE_SE, "%s:se init error, ret=%02x\r\n", __FUNCTION__, ret);
|
*p_des_len = 1;
|
goto Errout;
|
}
|
status = se_transmit_receive(&cmd_apdu, &rsp_apdu);
|
if (status != ESESTATUS_SUCCESS)
|
{
|
ret = (uint8_t)status;
|
LOG_ERROR(TRACE_MODULE_SE, "%s: se transceive error! ret=%02x\r\n", __FUNCTION__, ret);
|
*p_des_len = 1;
|
goto Errout;
|
}
|
else
|
{
|
*p_des_len = (uint8_t)rsp_apdu.len;
|
memcpy(p_des_data, rsp_apdu.p_data, rsp_apdu.len);
|
}
|
status = se_init(ESE_MODE_NORMAL);
|
if (status != ESESTATUS_SUCCESS)
|
{
|
LOG_ERROR(TRACE_MODULE_SE, "%s: last se init error, status=%02x\r\n", __FUNCTION__, (uint8_t)status);
|
}
|
if (DRV_OK != spi_close(SPI_ID1))
|
{
|
LOG_ERROR(TRACE_MODULE_SE, "%s: spi close error!\r\n", __FUNCTION__);
|
*p_des_len = 1;
|
return DRV_ERROR;
|
}
|
return DRV_OK;
|
|
Errout:
|
se_init(ESE_MODE_NORMAL);
|
spi_close(SPI_ID1);
|
return ret;
|
}
|
