418 lines
12 KiB
C++
418 lines
12 KiB
C++
/***************************************************************************
|
|
*
|
|
* Copyright 2015-2019 BES.
|
|
* All rights reserved. All unpublished rights reserved.
|
|
*
|
|
* No part of this work may be used or reproduced in any form or by any
|
|
* means, or stored in a database or retrieval system, without prior written
|
|
* permission of BES.
|
|
*
|
|
* Use of this work is governed by a license granted by BES.
|
|
* This work contains confidential and proprietary information of
|
|
* BES. which is protected by copyright, trade secret,
|
|
* trademark and other intellectual property rights.
|
|
*
|
|
****************************************************************************/
|
|
#include <stdio.h>
|
|
#include "cmsis_os.h"
|
|
#include "hal_uart.h"
|
|
#include "hal_timer.h"
|
|
#include "audioflinger.h"
|
|
#include "lockcqueue.h"
|
|
#include "hal_trace.h"
|
|
#include "hal_cmu.h"
|
|
#include "hal_chipid.h"
|
|
#include "analog.h"
|
|
#include "app_audio.h"
|
|
#include "app_status_ind.h"
|
|
#include "app_bt_stream.h"
|
|
#include "nvrecord.h"
|
|
#include "nvrecord_env.h"
|
|
//#include "nvrecord_dev.h"
|
|
|
|
#include "bluetooth.h"
|
|
#include "cqueue.h"
|
|
#ifdef MBED
|
|
#include "rtos.h"
|
|
#endif
|
|
#include "resources.h"
|
|
#include "app_spp_tota.h"
|
|
#include "app_tota_cmd_code.h"
|
|
#include "app_tota.h"
|
|
#include "app_spp.h"
|
|
#include "app_tota_cmd_handler.h"
|
|
#include "app_tota_data_handler.h"
|
|
|
|
#include "plat_types.h"
|
|
#include "sdp_api.h"
|
|
|
|
osMutexDef(tota_spp_gen_mutex);
|
|
|
|
static bool isTotaSppGeneralConnected = false;
|
|
static struct spp_device *tota_spp_gen_dev = NULL;
|
|
static struct spp_service *totaSppGenService = NULL;
|
|
static btif_sdp_record_t *tota_sdp_gen_record = NULL;
|
|
|
|
osThreadId tota_spp_gen_read_thread_id = NULL;
|
|
|
|
static app_spp_tota_tx_done_t app_spp_tota_gen_tx_done_func = NULL;
|
|
|
|
#if (TOTA_SHARE_TX_RX_BUF==1)
|
|
extern void app_spp_tota_share_buf_create(uint8_t** tota_tx_buf, uint8_t** tota_rx_buf);
|
|
extern bool app_spp_tota_is_to_share_buf(void);
|
|
extern uint8_t * app_spp_tota_share_tx_buf_get(void);
|
|
extern uint8_t * app_spp_tota_share_rx_buf_get(void);
|
|
extern uint16_t app_spp_tota_tx_buf_size(void);
|
|
#else
|
|
static uint8_t spp_rx_buf[SPP_RECV_BUFFER_SIZE];
|
|
static uint8_t totaSppGenTxBuf[TOTA_SPP_TX_BUF_SIZE];
|
|
#endif
|
|
|
|
static uint32_t occupiedTotaSppGenTxBufSize;
|
|
static uint32_t offsetToFillTotaSppGenTxData;
|
|
static uint8_t* ptrTotaSppGenTxBuf;
|
|
|
|
uint16_t app_spp_tota_gen_tx_buf_size(void)
|
|
{
|
|
return TOTA_SPP_TX_BUF_SIZE;
|
|
}
|
|
|
|
void app_spp_tota_gen_init_tx_buf(uint8_t* ptr)
|
|
{
|
|
ptrTotaSppGenTxBuf = ptr;
|
|
occupiedTotaSppGenTxBufSize = 0;
|
|
offsetToFillTotaSppGenTxData = 0;
|
|
}
|
|
|
|
static void app_spp_tota_gen_free_tx_buf(uint8_t* ptrData, uint32_t dataLen)
|
|
{
|
|
if (occupiedTotaSppGenTxBufSize > 0)
|
|
{
|
|
occupiedTotaSppGenTxBufSize -= dataLen;
|
|
}
|
|
TOTA_LOG_DBG(1,"occupiedTotaSppGenTxBufSize %d", occupiedTotaSppGenTxBufSize);
|
|
}
|
|
|
|
uint8_t* app_spp_tota_gen_fill_data_into_tx_buf(uint8_t* ptrData, uint32_t dataLen)
|
|
{
|
|
ASSERT((occupiedTotaSppGenTxBufSize + dataLen) < TOTA_SPP_TX_BUF_SIZE,
|
|
"Pending SPP General tx data has exceeded the tx buffer size !");
|
|
|
|
|
|
if ((offsetToFillTotaSppGenTxData + dataLen) > TOTA_SPP_TX_BUF_SIZE)
|
|
{
|
|
offsetToFillTotaSppGenTxData = 0;
|
|
}
|
|
|
|
uint8_t* filledPtr = ptrTotaSppGenTxBuf + offsetToFillTotaSppGenTxData;
|
|
memcpy(filledPtr, ptrData, dataLen);
|
|
|
|
offsetToFillTotaSppGenTxData += dataLen;
|
|
|
|
occupiedTotaSppGenTxBufSize += dataLen;
|
|
|
|
TOTA_LOG_DBG(3,"dataLen %d offsetToFillTotaSppGenTxData %d occupiedTotaSppGenTxBufSize %d",
|
|
dataLen, offsetToFillTotaSppGenTxData, occupiedTotaSppGenTxBufSize);
|
|
|
|
return filledPtr;
|
|
}
|
|
|
|
extern "C" APP_TOTA_CMD_RET_STATUS_E app_tota_data_received(uint8_t* ptrData, uint32_t dataLength);
|
|
extern "C" APP_TOTA_CMD_RET_STATUS_E app_tota_cmd_received(uint8_t* ptrData, uint32_t dataLength);
|
|
|
|
|
|
/****************************************************************************
|
|
* TOTA SPP SDP Entries
|
|
****************************************************************************/
|
|
#if 0
|
|
static const U8 TotaGenClassId[] = {
|
|
SDP_ATTRIB_HEADER_8BIT(3), /* Data Element Sequence, 6 bytes */
|
|
SDP_UUID_16BIT(SC_SERIAL_PORT), /* Hands-Free UUID in Big Endian */
|
|
};
|
|
//#else
|
|
/* 128 bit UUID in Big Endian a8b1fbc4-7855-4235-8633-ff36c8235e16 */
|
|
static const uint8_t TOTA_GENERAL_UUID_128[16] = {
|
|
0x16, 0x5e, 0x23, 0xc8, 0x36, 0xff, 0x33, 0x86, 0x35, 0x42, 0x55, 0x78, 0xc4, 0xfb, 0xb1, 0xa8};
|
|
|
|
/*---------------------------------------------------------------------------
|
|
*
|
|
* ServiceClassIDList
|
|
*/
|
|
static const U8 TotaGenClassId[] = {
|
|
SDP_ATTRIB_HEADER_8BIT(17), /* Data Element Sequence, 17 bytes */
|
|
SDP_UUID_128BIT(TOTA_GENERAL_UUID_128), /* 128 bit UUID in Big Endian */
|
|
};
|
|
#else
|
|
static const U8 TotaGenClassId[] = {
|
|
SDP_ATTRIB_HEADER_8BIT(17),
|
|
DETD_UUID + DESD_16BYTES,
|
|
0x8a,
|
|
0x48,\
|
|
0x2a,\
|
|
0x08,\
|
|
0x55,\
|
|
0x07,\
|
|
0x42,\
|
|
0xac,\
|
|
0xb6,\
|
|
0x73,\
|
|
0xa8,\
|
|
0x8d,\
|
|
0xf4,\
|
|
0x8b,\
|
|
0x3f,\
|
|
0xc7,
|
|
};
|
|
|
|
#endif
|
|
|
|
static const U8 TotaSppGenProtoDescList[] = {
|
|
SDP_ATTRIB_HEADER_8BIT(12), /* Data element sequence, 12 bytes */
|
|
|
|
/* Each element of the list is a Protocol descriptor which is a
|
|
* data element sequence. The first element is L2CAP which only
|
|
* has a UUID element.
|
|
*/
|
|
SDP_ATTRIB_HEADER_8BIT(3), /* Data element sequence for L2CAP, 3
|
|
* bytes
|
|
*/
|
|
|
|
SDP_UUID_16BIT(PROT_L2CAP), /* Uuid16 L2CAP */
|
|
|
|
/* Next protocol descriptor in the list is RFCOMM. It contains two
|
|
* elements which are the UUID and the channel. Ultimately this
|
|
* channel will need to filled in with value returned by RFCOMM.
|
|
*/
|
|
|
|
/* Data element sequence for RFCOMM, 5 bytes */
|
|
SDP_ATTRIB_HEADER_8BIT(5),
|
|
|
|
SDP_UUID_16BIT(PROT_RFCOMM), /* Uuid16 RFCOMM */
|
|
|
|
/* Uint8 RFCOMM channel number - value can vary */
|
|
SDP_UINT_8BIT(RFCOMM_CHANNEL_TOTA_GENERAL)
|
|
};
|
|
|
|
/*
|
|
* BluetoothProfileDescriptorList
|
|
*/
|
|
static const U8 TotaSppGenProfileDescList[] = {
|
|
SDP_ATTRIB_HEADER_8BIT(8), /* Data element sequence, 8 bytes */
|
|
|
|
/* Data element sequence for ProfileDescriptor, 6 bytes */
|
|
SDP_ATTRIB_HEADER_8BIT(6),
|
|
|
|
SDP_UUID_16BIT(SC_SERIAL_PORT), /* Uuid16 SPP */
|
|
SDP_UINT_16BIT(0x0102) /* As per errata 2239 */
|
|
};
|
|
|
|
/*
|
|
* * OPTIONAL * ServiceName
|
|
*/
|
|
static const U8 TotaSppGenServiceName1[] = {
|
|
SDP_TEXT_8BIT(8), /* Null terminated text string */
|
|
'S', 'p', 'p', 'G','e','n', '1','\0'
|
|
};
|
|
|
|
static const U8 TotaSppGenServiceName2[] = {
|
|
SDP_TEXT_8BIT(8), /* Null terminated text string */
|
|
'S', 'p', 'p', 'G','e','n', '2','\0'
|
|
};
|
|
|
|
/* SPP attributes.
|
|
*
|
|
* This is a ROM template for the RAM structure used to register the
|
|
* SPP SDP record.
|
|
*/
|
|
static sdp_attribute_t TotaSppGenSdpAttributes1[] = {
|
|
|
|
SDP_ATTRIBUTE(AID_SERVICE_CLASS_ID_LIST, TotaGenClassId),
|
|
|
|
SDP_ATTRIBUTE(AID_PROTOCOL_DESC_LIST, TotaSppGenProtoDescList),
|
|
|
|
SDP_ATTRIBUTE(AID_BT_PROFILE_DESC_LIST, TotaSppGenProfileDescList),
|
|
|
|
// SPP service name
|
|
SDP_ATTRIBUTE((AID_SERVICE_NAME + 0x0100), TotaSppGenServiceName1),
|
|
};
|
|
|
|
/*
|
|
static sdp_attribute_t TotaSppGenSdpAttributes2[] = {
|
|
|
|
SDP_ATTRIBUTE(AID_SERVICE_CLASS_ID_LIST, TotaGenClassId),
|
|
|
|
SDP_ATTRIBUTE(AID_PROTOCOL_DESC_LIST, TotaSppGenProtoDescList),
|
|
|
|
SDP_ATTRIBUTE(AID_BT_PROFILE_DESC_LIST, TotaSppGenProfileDescList),
|
|
|
|
// SPP service name
|
|
SDP_ATTRIBUTE((AID_SERVICE_NAME + 0x0100), TotaSppGenServiceName2),
|
|
};
|
|
*/
|
|
|
|
extern "C" void reset_programmer_state(unsigned char **buf, size_t *len);
|
|
extern unsigned char *g_buf;
|
|
extern size_t g_len;
|
|
|
|
static int tota_general_spp_handle_data_event_func(void *pDev, uint8_t process, uint8_t *pData, uint16_t dataLen)
|
|
{
|
|
TOTA_LOG_DBG(2,"[%s]data receive length = %d", __func__, dataLen);
|
|
TOTA_LOG_DUMP("[0x%x]", pData, dataLen);
|
|
// the first two bytes of the data packet is the fixed value 0xFFFF
|
|
app_tota_handle_received_data(pData, dataLen);
|
|
|
|
return 0;
|
|
}
|
|
|
|
#if 0
|
|
static void tota_spp_general_read_thread(const void *arg)
|
|
{
|
|
uint8_t buffer[TOTA_SPP_MAX_PACKET_SIZE];
|
|
U16 maxBytes;
|
|
|
|
while (1)
|
|
{
|
|
maxBytes = TOTA_SPP_MAX_PACKET_SIZE;
|
|
|
|
btif_spp_read(tota_spp_gen_dev, (char *)buffer, &maxBytes);
|
|
TOTA_LOG_DBG(2,"[%s]general data receive length = %d",__func__,maxBytes);
|
|
TOTA_LOG_DUMP("[0x%x]",buffer,maxBytes);
|
|
|
|
// the first two bytes of the data packet is the fixed value 0xFFFF
|
|
app_tota_handle_received_data(buffer, maxBytes);
|
|
}
|
|
}
|
|
|
|
static void app_spp_tota_gen_create_read_thread(void)
|
|
{
|
|
TOTA_LOG_DBG(2,"%s %d\n", __func__, __LINE__);
|
|
tota_spp_gen_read_thread_id = osThreadCreate(osThread(tota_spp_general_read_thread), NULL);
|
|
}
|
|
|
|
static void app_spp_tota_gen_close_read_thread(void)
|
|
{
|
|
TOTA_LOG_DBG(2,"%s %d\n", __func__, __LINE__);
|
|
if(tota_spp_gen_read_thread_id)
|
|
{
|
|
osThreadTerminate(tota_spp_gen_read_thread_id);
|
|
tota_spp_gen_read_thread_id = NULL;
|
|
}
|
|
}
|
|
#endif
|
|
static void spp_tota_gen_callback(struct spp_device *locDev, struct spp_callback_parms *Info)
|
|
{
|
|
TOTA_LOG_DBG(1,"%s",__func__);
|
|
if (BTIF_SPP_EVENT_REMDEV_CONNECTED == Info->event)
|
|
{
|
|
TOTA_LOG_DBG(1,"::SPP_GENERAL_EVENT_REMDEV_CONNECTED %d\n", Info->event);
|
|
isTotaSppGeneralConnected = true;
|
|
// app_spp_tota_gen_create_read_thread();
|
|
app_tota_general_connected(APP_TOTA_CONNECTED);
|
|
app_tota_update_datapath(APP_TOTA_GEN_VIA_SPP);
|
|
//conn_stop_connecting_mobile_supervising();
|
|
}
|
|
else if (BTIF_SPP_EVENT_REMDEV_DISCONNECTED == Info->event)
|
|
{
|
|
TOTA_LOG_DBG(1,"::SPP_GENERAL_EVENT_REMDEV_DISCONNECTED %d\n", Info->event);
|
|
isTotaSppGeneralConnected = false;
|
|
// app_spp_tota_gen_close_read_thread();
|
|
app_tota_disconnected(APP_TOTA_DISCONNECTED);
|
|
app_tota_update_datapath(APP_TOTA_PATH_IDLE);
|
|
|
|
app_spp_tota_gen_tx_done_func = NULL;
|
|
}
|
|
else if (BTIF_SPP_EVENT_DATA_SENT == Info->event)
|
|
{
|
|
//app_spp_tota_gen_free_tx_buf(Info->tx_buf, Info->tx_data_len);
|
|
struct spp_tx_done *pTxDone = (struct spp_tx_done *)(Info->p.other);
|
|
app_spp_tota_gen_free_tx_buf(pTxDone->tx_buf, pTxDone->tx_data_length);
|
|
if (app_spp_tota_gen_tx_done_func)
|
|
{
|
|
app_spp_tota_gen_tx_done_func();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TOTA_LOG_DBG(1,"::spp general unknown event %d\n", Info->event);
|
|
}
|
|
}
|
|
|
|
static void app_spp_tota_gen_send_data(uint8_t* ptrData, uint16_t length)
|
|
{
|
|
if (!isTotaSppGeneralConnected)
|
|
{
|
|
return;
|
|
}
|
|
|
|
btif_spp_write(tota_spp_gen_dev, (char *)ptrData, &length);
|
|
}
|
|
|
|
void app_tota_gen_send_cmd_via_spp(uint8_t* ptrData, uint32_t length)
|
|
{
|
|
uint8_t* ptrBuf = app_spp_tota_gen_fill_data_into_tx_buf(ptrData, length);
|
|
app_spp_tota_gen_send_data(ptrBuf, (uint16_t)length);
|
|
}
|
|
|
|
void app_tota_gen_send_data_via_spp(uint8_t* ptrData, uint32_t length)
|
|
{
|
|
TOTA_LOG_DBG(2,"[%s]tota gen send data length = %d",__func__,length);
|
|
uint8_t* ptrBuf = app_spp_tota_gen_fill_data_into_tx_buf(ptrData, length);
|
|
app_spp_tota_gen_send_data(ptrBuf, (uint16_t)length);
|
|
}
|
|
|
|
void app_spp_tota_gen_init(void)
|
|
{
|
|
uint8_t *rx_buf;
|
|
uint8_t *tx_buf;
|
|
osMutexId mid;
|
|
btif_sdp_record_param_t param;
|
|
|
|
if (tota_spp_gen_dev == NULL)
|
|
{
|
|
tota_spp_gen_dev = btif_create_spp_device();
|
|
}
|
|
|
|
if(app_spp_tota_is_to_share_buf() == true){
|
|
app_spp_tota_share_buf_create(&tx_buf,&rx_buf);
|
|
}
|
|
#if (TOTA_SHARE_TX_RX_BUF==0)
|
|
else{
|
|
rx_buf = &spp_rx_buf[0];
|
|
tx_buf = &totaSppGenTxBuf[0];
|
|
}
|
|
#endif
|
|
tota_spp_gen_dev->rx_buffer = rx_buf;
|
|
|
|
app_spp_tota_gen_init_tx_buf(tx_buf);
|
|
btif_spp_init_rx_buf(tota_spp_gen_dev, rx_buf, SPP_RECV_BUFFER_SIZE);
|
|
|
|
mid = osMutexCreate(osMutex(tota_spp_gen_mutex));
|
|
if (!mid) {
|
|
ASSERT(0, "cannot create mutex");
|
|
}
|
|
|
|
if (tota_sdp_gen_record == NULL)
|
|
tota_sdp_gen_record = btif_sdp_create_record();
|
|
|
|
param.attrs = &TotaSppGenSdpAttributes1[0],
|
|
param.attr_count = ARRAY_SIZE(TotaSppGenSdpAttributes1);
|
|
param.COD = BTIF_COD_MAJOR_PERIPHERAL;
|
|
btif_sdp_record_setup(tota_sdp_gen_record, ¶m);
|
|
|
|
if(totaSppGenService == NULL)
|
|
totaSppGenService = btif_create_spp_service();
|
|
|
|
totaSppGenService->rf_service.serviceId = RFCOMM_CHANNEL_TOTA_GENERAL;
|
|
totaSppGenService->numPorts = 0;
|
|
btif_spp_service_setup(tota_spp_gen_dev, totaSppGenService, tota_sdp_gen_record);
|
|
|
|
tota_spp_gen_dev->portType = BTIF_SPP_SERVER_PORT;
|
|
tota_spp_gen_dev->app_id = BTIF_APP_SPP_SERVER_TOTA_GENERAL_ID;
|
|
tota_spp_gen_dev->spp_handle_data_event_func = tota_general_spp_handle_data_event_func;
|
|
|
|
btif_spp_init_device(tota_spp_gen_dev, 5, mid);
|
|
|
|
btif_spp_open(tota_spp_gen_dev, NULL,spp_tota_gen_callback);
|
|
|
|
}
|