ChinaUWBProject.git

对比新文件
			@@ -0,0 +1,291 @@
			/*
			* 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;
			}