/*********************************************************************
* INCLUDES
*/
#include "ppsp_impl.h"
#include "ppsp_serv.h"
#include "error.h"
#include "OSAL.h"
#include "core_queu.h"
#include "log.h"
#include "tinycrypt/aes.h"
//#include "ali_genie_profile.h"
//#include "tbrsh_motr_pwms.h"
//#include "tbrsh_leds_pwms.h"
#define PPSP_IMPL_CFGS_BUSY_STAT_BITS 0x00000001
#define PPSP_IMPL_CFGS_AUTH_STAT_BITS 0x00000002
#define PPSP_IMPL_CFGS_OTAS_STAT_BITS 0x00000004 // ota bgns
#define PPSP_IMPL_CFGS_OTAE_STAT_BITS 0x00000008 // ota ends
#define PPSP_IMPL_CFGS_ALIS_PIDS_COUN 4
#define PPSP_IMPL_CFGS_ALIS_MACS_COUN 6
#define PPSP_IMPL_CFGS_ALIS_SCRT_COUN 16
#define PPSP_IMPL_CFGS_MSGS_HDER_SIZE 4
#define PPSP_IMPL_CFGS_OPCO_MISN_ISSU 0x02 // issu by master, resp by slave
#define PPSP_IMPL_CFGS_OPCO_MISR_RESP 0x03 // resp by slave, issu by master
#define PPSP_IMPL_CFGS_OPCO_MNSI_ISSU 0x04 // issu by slave, resp by master
#define PPSP_IMPL_CFGS_OPCO_MRSI_RESP 0x05 // resp by master, issu by slave
#define PPSP_IMPL_CFGS_OPCO_NRSP_ISSU 0x06 // issu W/O resp
#define PPSP_IMPL_CFGS_OPCO_RAND_ISSU 0x10 // issu RAND by master, resp by slave
#define PPSP_IMPL_CFGS_OPCO_CIPR_RESP 0x11 // resp RAND by slave, issu by master. CIPR = ENCR(RAND, BKEY(RAND,MACS,SCRT))
#define PPSP_IMPL_CFGS_OPCO_VERF_ISSU 0x12 // issu VERF by master, resp by slave. verify result of encryption
#define PPSP_IMPL_CFGS_OPCO_BKEY_RESP 0x13 // resp VERF by slave, issu by master
#define PPSP_IMPL_CFGS_OPCO_NWRK_ISSU 0x14 // issu NWRK by master, resp by slave. networking rsult, unprov/proved
#define PPSP_IMPL_CFGS_OPCO_NWRK_RESP 0x15 // resp NWRK by slave, issu by master. confirm of networking rsult
#define PPSP_IMPL_CFGS_OPCO_VERS_ISSU 0x20 // issu VERS by master, resp by slave
#define PPSP_IMPL_CFGS_OPCO_VERS_RESP 0x21 // resp VERS by slave, issu by master
#define PPSP_IMPL_CFGS_OPCO_UPDA_ISSU 0x22 // issu UPDA by master, resp by slave
#define PPSP_IMPL_CFGS_OPCO_UPDA_RESP 0x23 // resp UPDA by slave, issu by master. confirm, rcvd size, fast mode
#define PPSP_IMPL_CFGS_OPCO_PACK_ISSU 0x2F // issu PACK by master, issu W/O resp.
#define PPSP_IMPL_CFGS_OPCO_PACK_RESP 0x24 // issu PACK by slave, issu W/O resp. confirm of total frame
#define PPSP_IMPL_CFGS_OPCO_COMP_ISSU 0x25 // issu COMP by master, resp by slave. complete of transfer
#define PPSP_IMPL_CFGS_OPCO_COMP_RESP 0x26 // resp COMP by slave, issu by master. reply with crc
#define PPSP_IMPL_CFGS_OPCO_USER_ISSU 0xFE // issu USER, resp by slave
#define PPSP_IMPL_CFGS_OPCO_USER_RESP 0xFF // issu USER, resp by slave
#define PPSP_IMPL_CFGS_PROG_ADDR_BASE (0x11000000)
#define PPSP_IMPL_CFGS_PROG_SCTR_SIZE (0x1000) // program sector size in byte
#define PPSP_IMPL_CFGS_PROG_ADDR_BGNS (0x50000) // program data bgn address of flash
#define PPSP_IMPL_CFGS_PROG_FLSH_SIZE (0x30000) // program total size in byte
#define PPSP_IMPL_CFGS_PROG_ADDR_ENDS (PPSP_IMPL_CFGS_PROG_ADDR_BGNS+PPSP_IMPL_CFGS_PROG_FLSH_SIZE) // program data end address of flash
#define PPSP_IMPL_CFGS_PROG_VERS_REVI (1)
#define PPSP_IMPL_CFGS_PROG_VERS_MINR (0)
#define PPSP_IMPL_CFGS_PROG_VERS_MAJR (1)
extern void
ppsp_impl_serv_rcvd_hdlr(uint8 para, uint8 coun);
static ppsp_serv_appl_CBs_t
__ppsp_impl_hdlr_serv = {
ppsp_impl_serv_rcvd_hdlr,
};
static uint32
__ppsp_impl_stat_bits_flag = 0x00;
static uint32
__ppsp_impl_proc_tout_coun = 0x00;
static core_sque_t*
__ppsp_impl_msgs_queu_rcvd = NULL; // received msgs queue
static core_sque_t*
__ppsp_impl_msgs_queu_xfer = NULL; // transfer msgs queue
static const uint8
__ppsp_impl_opco_prim_list[] = {
PPSP_IMPL_CFGS_OPCO_MISN_ISSU,
PPSP_IMPL_CFGS_OPCO_MNSI_ISSU,
PPSP_IMPL_CFGS_OPCO_MISR_RESP,
PPSP_IMPL_CFGS_OPCO_MRSI_RESP,
PPSP_IMPL_CFGS_OPCO_NRSP_ISSU,
PPSP_IMPL_CFGS_OPCO_RAND_ISSU,
PPSP_IMPL_CFGS_OPCO_CIPR_RESP,
PPSP_IMPL_CFGS_OPCO_VERF_ISSU,
PPSP_IMPL_CFGS_OPCO_BKEY_RESP,
PPSP_IMPL_CFGS_OPCO_NWRK_ISSU,
PPSP_IMPL_CFGS_OPCO_NWRK_RESP,
PPSP_IMPL_CFGS_OPCO_VERS_ISSU,
PPSP_IMPL_CFGS_OPCO_VERS_RESP,
PPSP_IMPL_CFGS_OPCO_UPDA_ISSU,
PPSP_IMPL_CFGS_OPCO_UPDA_RESP,
PPSP_IMPL_CFGS_OPCO_PACK_ISSU,
PPSP_IMPL_CFGS_OPCO_PACK_RESP,
PPSP_IMPL_CFGS_OPCO_COMP_ISSU,
PPSP_IMPL_CFGS_OPCO_COMP_RESP,
PPSP_IMPL_CFGS_OPCO_USER_ISSU,
PPSP_IMPL_CFGS_OPCO_USER_RESP,
};
static uint8
__ppsp_impl_opco_prim_coun = sizeof(__ppsp_impl_opco_prim_list);
static uint8
__ppsp_impl_opco_user_coun = 0;
static uint8*
__ppsp_impl_opco_user_list = 0;
static uint8
__ppsp_impl_auth_keys_data[16];
/*
* private function prototype
*/
// static uint8
// ppsp_impl_psh_msgs_xfer(const uint8* data, uint16 leng);
/*
* private function implimentation
*/
#define ppsp_impl_get_auth_rslt(rslt) \
{ \
(rslt) = ((__ppsp_impl_stat_bits_flag & PPSP_IMPL_CFGS_AUTH_STAT_BITS)?1:0); \
}
#define ppsp_impl_set_auth_rslt(flag) \
{ \
if ( 0 == (flag) ) \
__ppsp_impl_stat_bits_flag &= ~PPSP_IMPL_CFGS_AUTH_STAT_BITS; \
else \
__ppsp_impl_stat_bits_flag |= PPSP_IMPL_CFGS_AUTH_STAT_BITS; \
}
#define ppsp_impl_get_msgs_numb(msgs, numb) \
{ \
if ( 0 != msgs ) \
(numb) = msgs[0]&0x0F; \
}
#define ppsp_impl_set_msgs_numb(msgs, numb) \
{ \
if ( 0 != msgs ) \
msgs[0] |= (numb)&0x0F; \
}
#define ppsp_impl_get_msgs_encr(msgs, numb) \
{ \
if ( 0 != msgs ) \
(numb) = ((msgs[0]&0x10)>>4); \
}
#define ppsp_impl_set_msgs_encr(msgs, flag) \
{ \
if ( 0 != msgs ) \
msgs[0] |= (((flag)&0x01)<<4); \
}
#define ppsp_impl_get_msgs_opco(msgs, opco) \
{ \
if ( 0 != msgs ) \
(opco) = msgs[1]&0xFF; \
}
#define ppsp_impl_set_msgs_opco(msgs, opco) \
{ \
if ( 0 != msgs ) \
msgs[1] = (opco)&0xFF; \
}
#define ppsp_impl_get_msgs_seqn(msgs, alln, seqn) \
{ \
if ( 0 != msgs ) { \
alln = (msgs[2]&0xF0)>>4; \
seqn = (msgs[2]&0x0F)>>0; \
} \
}
#define ppsp_impl_set_msgs_seqn(msgs, alln, seqn) \
{ \
if ( 0 != msgs ) \
msgs[2] = ((alln&0x0F))<<4 | ((seqn&0x0F)<<0); \
}
/*
* desc: get msg payload length, byte 3 of header
*/
#define ppsp_impl_get_msgs_frsz(msgs, frsz) \
{ \
if ( 0 != msgs ) \
(frsz) = msgs[3]&0xFF; \
}
#define ppsp_impl_set_msgs_frsz(msgs, frsz) \
{ \
if ( 0 != msgs ) \
msgs[3] = (frsz)&0xFF; \
}
/*
* desc: get msg payload
*/
#define ppsp_impl_get_msgs_plds(msgs, data) \
{ \
if ( 0 != msgs ) \
((uint8*)(data)) = (((uint8*)(msgs))+PPSP_IMPL_CFGS_MSGS_HDER_SIZE); \
}
/*
* desc: set msg payload
*/
#define ppsp_impl_set_msgs_plds(msgs, data, coun) \
{ \
if ( 0 != (uint8*)(msgs) ) \
osal_memcpy(((uint8*)(msgs))+PPSP_IMPL_CFGS_MSGS_HDER_SIZE, (uint8*)(data), coun); \
}
/*
* desc: PKCS#7 padding
*/
#define ppsp_impl_get_pkcs_7pad(bksz, dasz, pval) \
{ \
pval = bksz - (dasz % bksz); \
}
/*
* desc: chk mesg package size
*/
static uint8
ppsp_impl_chk_msgs_leng(const uint8* mesg, uint16 coun)
{
return ( NULL != mesg && PPSP_IMPL_CFGS_MSGS_HDER_SIZE <= coun );
}
/*
* desc: chk mesg id
*/
static uint8
ppsp_impl_chk_msgs_numb(const uint8* mesg, uint16 coun)
{
uint8 rslt = 0;
if ( 0 != mesg ) {
uint8 numb;
ppsp_impl_get_msgs_numb(mesg, numb);
rslt = ((0 <= numb) && (15 >= numb));
} else {
rslt = 0;
}
return ( rslt );
}
/*
* desc: chk mesg opcode
*/
static uint8
ppsp_impl_chk_msgs_opco(const uint8* mesg, uint16 coun)
{
uint8 rslt = 0;
if ( NULL != mesg ) {
uint8 opco;
opco = mesg[1] & 0xFF;
for ( int itr0 = 0; itr0 < __ppsp_impl_opco_prim_coun; itr0 += 1 ) {
if ( rslt = (opco == __ppsp_impl_opco_prim_list[itr0]) ) {
break;
}
}
if ( !rslt )
for ( int itr0 = 0; itr0 < __ppsp_impl_opco_user_coun; itr0 += 1 ) {
if ( rslt = (opco == __ppsp_impl_opco_user_list[itr0]) ) {
break;
}
}
}
return ( rslt );
}
/*
* desc: chk mesg segment number + total segment number
*/
static uint8
ppsp_impl_chk_msgs_seqn(const uint8* mesg, uint16 coun)
{
uint8 rslt = 1;
if ( NULL != mesg ) {
uint8 numb;
/* numb of segment sequence */
numb = (mesg[2] & 0x0F) >> 0;
rslt = (0 <= numb && 15 >= numb);
}
if ( 1 == rslt ) {
uint8 numb;
/* numb of total segments */
numb = (mesg[2] & 0xF0) >> 4;
rslt = (0 <= numb && 15 >= numb);
}
return ( rslt );
}
/*
* desc: create response message
*/
static void*
ppsp_impl_new_msgs_resp(uint8 numb, uint8 opco, uint8* data, uint16 leng)
{
uint8* msgs = 0;
/* only consider unsegmented case */
msgs = osal_mem_alloc(PPSP_IMPL_CFGS_MSGS_HDER_SIZE+leng);
if ( 0 != msgs ) {
osal_memset(msgs, 0, PPSP_IMPL_CFGS_MSGS_HDER_SIZE+leng);
ppsp_impl_set_msgs_numb(msgs, numb);
// ppsp_impl_set_msgs_encr(msgs, numb);
// ppsp_impl_set_msgs_vers(msgs, numb);
ppsp_impl_set_msgs_opco(msgs, opco);
ppsp_impl_set_msgs_seqn(msgs, 0, 0); // frame numb, frame sequ
ppsp_impl_set_msgs_frsz(msgs, leng); // frame size
ppsp_impl_set_msgs_plds(msgs, data, leng); // payload
// LOG("\r\nmsgs: >>> ");
// for ( uint8 itr0 = 0; itr0 < PPSP_IMPL_CFGS_MSGS_HDER_SIZE+leng; itr0 += 1 ) {
// LOG("%02x,", msgs[itr0]);
// }
// LOG("msgs: <<< \r\n");
}
return ( msgs );
}
static uint8
ppsp_impl_psh_msgs_rcvd(const uint8* mesg, uint16 coun)
{
uint8 rslt = 1;
if ( 0 == mesg ) {
LOG("[PANDA][ERR] NULL POINTER !!!");
rslt = 0;
}
// for (uint8 itr0 = 0; itr0 < coun; itr0 += 1)
// LOG("[PANDA][INF] rcvd msg: data[%d]=%02x", itr0, mesg[itr0]);
/* */
if ( 1 == rslt ) {
rslt = ppsp_impl_chk_msgs_leng(mesg, coun);
// LOG("[PANDA][INF] ppsp_impl_chk_msgs_leng: %s\n\r", rslt ? "OK" :"NG");
// printf("[PANDA][INF] ppsp_impl_chk_msgs_leng: %s\n\r", rslt ? "OK" :"NG");
}
/* */
if ( 1 == rslt ) {
rslt = ppsp_impl_chk_msgs_numb(mesg, coun);
// LOG("[PANDA][ERR] ppsp_impl_chk_msgs_numb: %s\n\r", rslt ? "OK" :"NG");
// printf("[PANDA][ERR] ppsp_impl_chk_msgs_numb: %s\n\r", rslt ? "OK" :"NG");
}
/* */
if ( 1 == rslt ) {
rslt = ppsp_impl_chk_msgs_opco(mesg, coun);
// LOG("[PANDA][ERR] ppsp_impl_chk_msgs_opco: %s\n\r", rslt ? "OK" :"NG");
// printf("[PANDA][ERR] ppsp_impl_chk_msgs_opco: %s\n\r", rslt ? "OK" :"NG");
}
/* */
if ( 1 == rslt ) {
rslt = ppsp_impl_chk_msgs_seqn(mesg, coun);
// LOG("[PANDA][ERR] ppsp_impl_chk_msgs_seqn: %s\n\r", rslt ? "OK" :"NG");
// printf("[PANDA][ERR] ppsp_impl_chk_msgs_seqn: %s\n\r", rslt ? "OK" :"NG");
}
/* */
if ( 1 == rslt ) {
uint8* vmsg = osal_mem_alloc(coun);
osal_memcpy(vmsg, mesg, coun);
core_sque_psh(__ppsp_impl_msgs_queu_rcvd, &vmsg);
// if segment msg, enqueue();
// else notify upper layer new msgs
// __ppsp_impl_msgs_rcvd = (uint8*)data;
}
return ( rslt );
}
static uint8
ppsp_impl_psh_msgs_xfer(const uint8* data, uint16 leng)
{
core_sque_psh(__ppsp_impl_msgs_queu_xfer, &data);
}
static void
ppsp_impl_cvt_hex2Str(const unsigned char* const srcs, unsigned char* dest, int coun, int revs)
{
}
static void
ppsp_impl_prc_msgs_rand(uint8* msgs_rcvd)
{
uint8 itr0;
uint8 msgn;
uint8 rsiz;
uint8* rand;
ppsp_impl_get_msgs_numb(msgs_rcvd, msgn); // mesg id
ppsp_impl_get_msgs_frsz(msgs_rcvd, rsiz); // rand size
ppsp_impl_get_msgs_plds(msgs_rcvd, rand); // rand pointer
uint8 pids[PPSP_IMPL_CFGS_ALIS_PIDS_COUN];
uint8 macs[PPSP_IMPL_CFGS_ALIS_MACS_COUN];
uint8 scrt[PPSP_IMPL_CFGS_ALIS_SCRT_COUN];
//load PID
ppsp_impl_get_pids(pids);
//load MAC
ppsp_impl_get_macs(macs);
ppsp_impl_get_scrt(scrt);
if ( 1 == ppsp_impl_cal_keys(rand, rsiz, pids, sizeof(pids), macs, sizeof(macs), scrt, sizeof(scrt)) ) {
LOG("\n\rKEY:>>> "); for ( itr0 = 0; itr0 < sizeof(__ppsp_impl_auth_keys_data); itr0 ++ ) LOG("%02x,", __ppsp_impl_auth_keys_data[itr0]); LOG("KEY:<<< \n\r");
uint8* msgs_xfer = 0;
uint8 cipr[16] = { 0x00, }; // ciper
ppsp_impl_enc_text(rand, cipr);
LOG("\n\rCIP:>>> "); for ( itr0 = 0; itr0 < sizeof(cipr); itr0 ++ ) LOG("%02x,", cipr[itr0]); LOG("KEY:<<< \n\r");
msgs_xfer = ppsp_impl_new_msgs_resp(msgn, PPSP_IMPL_CFGS_OPCO_CIPR_RESP, cipr, sizeof(cipr));
if ( 0 != msgs_xfer ) ppsp_impl_psh_msgs_xfer(msgs_xfer, 20);
} else {
LOG("[PANDA][ERR] gen_aligenie_auth_key FAIL !!!");
}
}
static void
ppsp_impl_prc_msgs_verf(uint8* msgs_rcvd)
{
uint8 msgn;
uint8 frsz;
uint8* plds;
ppsp_impl_get_msgs_numb(msgs_rcvd, msgn);
ppsp_impl_get_msgs_frsz(msgs_rcvd, frsz);
ppsp_impl_get_msgs_plds(msgs_rcvd, plds);
if ( NULL != plds && 0 == plds[0] ) {
uint8* msgs_xfer = 0;
/* Auth Success */
ppsp_impl_set_auth_rslt(1);
msgs_xfer = ppsp_impl_new_msgs_resp(msgn, PPSP_IMPL_CFGS_OPCO_BKEY_RESP, plds, frsz);
if ( 0 != msgs_xfer ) ppsp_impl_psh_msgs_xfer(msgs_xfer, 20);
}
}
static void
ppsp_impl_prc_msgs_nwrk(uint8* msgs_rcvd)
{
uint8 msgn;
uint8 encr;
uint8 frsz;
uint8* plds;
ppsp_impl_get_msgs_numb(msgs_rcvd, msgn);
ppsp_impl_get_msgs_encr(msgs_rcvd, encr);
ppsp_impl_get_msgs_frsz(msgs_rcvd, frsz);
ppsp_impl_get_msgs_plds(msgs_rcvd, plds);
uint8 text[16];
if ( 0x01 == encr ) {
ppsp_impl_dec_cipr(text, plds);
}
if ( 0 == text[0] ) {
LOG("NETW EXIT DONE");
} else
if ( 1 == text[0] ) {
LOG("NETW CFGS DONE");
}
uint8 padd;
ppsp_impl_get_pkcs_7pad(16, 1, padd);
osal_memset(text, padd, sizeof(text));
text[0] = 0x01;
uint8 cipr[16];
if ( 0x01 == encr ) {
ppsp_impl_enc_text(text, cipr);
}
uint8* xfer = ppsp_impl_new_msgs_resp(msgn, PPSP_IMPL_CFGS_OPCO_NWRK_RESP, cipr, sizeof(cipr));
ppsp_impl_set_msgs_encr(xfer, encr);
if ( 0 != xfer ) ppsp_impl_psh_msgs_xfer(xfer, 20);
}
/*****************************************************************************/
// ota relative
uint8 __ppsp_impl_upda_type;
uint32 __ppsp_impl_upda_vers;
uint32 __ppsp_impl_upda_fwsz;
uint16 __ppsp_impl_upda_crcs; // crc from upstream
uint8 __ppsp_impl_upda_flag;
uint8 __ppsp_impl_upda_buff[256];
uint16 __ppsp_impl_upda_offs; // offset of filled posi
uint32 __ppsp_impl_upda_wrsz;
uint16 __ppsp_impl_upda_crcd; // crc calc on local
uint32 __ppsp_impl_upda_dnsz;
static uint8
ppsp_impl_era_prog_data(uint32 addr)
{
uint8 rslt = PPlus_ERR_FATAL;
// flash address range check
if ( PPSP_IMPL_CFGS_PROG_ADDR_BGNS > addr || PPSP_IMPL_CFGS_PROG_ADDR_ENDS <= addr ) {
rslt = PPlus_ERR_INVALID_ADDR;
goto RSLT_FAIL_ADDR;
}
flash_sector_erase(PPSP_IMPL_CFGS_PROG_ADDR_BASE + (addr&0xFFF000));
rslt = PPlus_SUCCESS;
RSLT_FAIL_ADDR:
return ( rslt );
}
static uint8
ppsp_impl_pul_prog_data(uint32 addr, uint32* valu)
{
uint8 rslt = PPlus_ERR_FATAL;
// flash address range check
if ( PPSP_IMPL_CFGS_PROG_ADDR_BGNS > addr || PPSP_IMPL_CFGS_PROG_ADDR_ENDS <= addr ) {
rslt = PPlus_ERR_INVALID_ADDR;
goto RSLT_FAIL_ADDR;
}
// 4 bytes aligned
if ( addr & 0x000003 ) {
rslt = PPlus_ERR_DATA_ALIGN;
goto RSLT_FAIL_ADDR;
}
*valu = read_reg(PPSP_IMPL_CFGS_PROG_ADDR_BASE + addr);
rslt = PPlus_SUCCESS;
RSLT_FAIL_ADDR:
return ( rslt );
}
static uint8
ppsp_impl_psh_prog_data(uint32 addr, uint32 valu)
{
uint8 rslt = PPlus_ERR_FATAL;
// flash address range check
if ( PPSP_IMPL_CFGS_PROG_ADDR_BGNS > addr || PPSP_IMPL_CFGS_PROG_ADDR_ENDS <= addr ) {
rslt = PPlus_ERR_INVALID_ADDR;
goto RSLT_FAIL_ADDR;
}
// 4 bytes aligned
if ( addr & 0x000003 ) {
rslt = PPlus_ERR_DATA_ALIGN;
goto RSLT_FAIL_ADDR;
}
if ( 0 == ProgramWord(PPSP_IMPL_CFGS_PROG_ADDR_BASE + addr, (uint8*)&valu, sizeof(valu)) ) {
rslt = PPlus_ERR_FATAL;
goto RSLT_FAIL_PROG;
}
rslt = PPlus_SUCCESS;
RSLT_FAIL_PROG:
RSLT_FAIL_ADDR:
return ( rslt );
}
static uint16
ppsp_impl_cal_crc16_CCITT_FALSE(uint16 crci, uint8* data, uint32 coun)
{
uint16 wCRCin = crci;
uint16 wCPoly = 0x1021;
while (coun--) {
wCRCin ^= (*(data++) << 8);
for (int i = 0; i < 8; i++) {
if (wCRCin & 0x8000)
wCRCin = (wCRCin << 1) ^ wCPoly;
else
wCRCin = wCRCin << 1;
}
}
return (wCRCin);
}
static void
ppsp_impl_prc_msgs_vers(uint8* msgs)
{
uint8 msgn;
uint8 encr;
uint8 frsz;
uint8* plds;
ppsp_impl_get_msgs_numb(msgs, msgn);
ppsp_impl_get_msgs_encr(msgs, encr);
ppsp_impl_get_msgs_frsz(msgs, frsz);
ppsp_impl_get_msgs_plds(msgs, plds);
if ( (0x01 == encr && 0x10 != frsz) || (0x00 == encr && 0x01 != frsz) ) {
LOG("%s, !! INVALID MESG CONTENT !!");
goto RSLT_FAIL_MESG;
}
uint8 text[16], size, offs, padd; // plain text, text size, offset, padding byte;
if ( 0x01 == encr ) {
ppsp_impl_dec_cipr(text, plds);
} else {
osal_memcpy(text, plds, frsz);
}
text[0] = (0x00==text[0]) ? 0x00 : 0xFF; // type
text[1] = PPSP_IMPL_CFGS_PROG_VERS_REVI; // revision
text[2] = PPSP_IMPL_CFGS_PROG_VERS_MINR; // minor
text[3] = PPSP_IMPL_CFGS_PROG_VERS_MAJR; // major
text[4] = 0x00; // reserved
size = sizeof(text);
offs = 5;
uint8 cipr[16]; // ciper
if ( 0x01 == encr ) {
ppsp_impl_get_pkcs_7pad(size, offs, padd);
osal_memset(text+offs, padd, size-offs);
ppsp_impl_enc_text(text, cipr);
}
uint8* xfer;
if ( 0x01 == encr ) {
xfer = ppsp_impl_new_msgs_resp(msgn, PPSP_IMPL_CFGS_OPCO_VERS_RESP, cipr, sizeof(cipr));
} else {
xfer = ppsp_impl_new_msgs_resp(msgn, PPSP_IMPL_CFGS_OPCO_VERS_RESP, text, offs);
}
ppsp_impl_set_msgs_encr(xfer, encr);
if ( 0 != xfer ) ppsp_impl_psh_msgs_xfer(xfer, 20);
// if ( __ppsp_impl_stat_bits_flag & PPSP_IMPL_CFGS_OTAE_STAT_BITS ) {
// __ppsp_impl_stat_bits_flag &= ~PPSP_IMPL_CFGS_OTAE_STAT_BITS;
// write_reg(0x4000f034, 0); // flag as an OTAs auto reset
// }
RSLT_FAIL_MESG:
}
static void
ppsp_impl_prc_msgs_upda(uint8* msgs)
{
uint8 msgn;
uint8 encr;
uint8 frsz;
uint8* plds;
ppsp_impl_get_msgs_numb(msgs, msgn);
ppsp_impl_get_msgs_encr(msgs, encr);
ppsp_impl_get_msgs_frsz(msgs, frsz);
ppsp_impl_get_msgs_plds(msgs, plds);
if ( (0x01 == encr && 0x10 != frsz) || (0x00 == encr && 0x0C != frsz) ) {
LOG("%s, !! INVALID MESG CONTENT !! \r\n");
goto RSLT_FAIL_MESG;
}
// plain text, text size, offset, padding byte
uint8 cipr_text[16], text_size, padd_offs, padd_valu;
if ( 0x01 == encr ) {
ppsp_impl_dec_cipr(cipr_text, plds);
} else {
osal_memcpy(cipr_text, plds, frsz);
}
uint8 copy_offs = 0;
osal_memcpy(&__ppsp_impl_upda_type, cipr_text+copy_offs, sizeof(__ppsp_impl_upda_type)); // fw type
copy_offs += sizeof(__ppsp_impl_upda_type);
osal_memcpy(&__ppsp_impl_upda_vers, cipr_text+copy_offs, sizeof(__ppsp_impl_upda_vers)); // fw version
copy_offs += sizeof(__ppsp_impl_upda_vers);
osal_memcpy(&__ppsp_impl_upda_fwsz, cipr_text+copy_offs, sizeof(__ppsp_impl_upda_fwsz)); // fw size in byte
copy_offs += sizeof(__ppsp_impl_upda_fwsz);
osal_memcpy(&__ppsp_impl_upda_crcs, cipr_text+copy_offs, sizeof(__ppsp_impl_upda_crcs)); // crc16
copy_offs += sizeof(__ppsp_impl_upda_crcs);
osal_memcpy(&__ppsp_impl_upda_flag, cipr_text+copy_offs, sizeof(__ppsp_impl_upda_flag)); // flag: 0:full update, 1:incr update
LOG("%s, type:%x,vers:%x,size:%x,crcs:%x,flag:%x \r\n",
__func__, __ppsp_impl_upda_type, __ppsp_impl_upda_vers, __ppsp_impl_upda_fwsz, __ppsp_impl_upda_crcs, __ppsp_impl_upda_flag);
if ( PPSP_IMPL_CFGS_PROG_FLSH_SIZE < __ppsp_impl_upda_fwsz ) {
LOG("%s, !! FIRMWARE SIZE EXCEED LIMIT OF %d BYTES !! \r\n", __func__, PPSP_IMPL_CFGS_PROG_FLSH_SIZE);
goto RSLT_FAIL_FWSZ;
}
uint32 sctr = (__ppsp_impl_upda_fwsz/PPSP_IMPL_CFGS_PROG_SCTR_SIZE) + (__ppsp_impl_upda_fwsz%PPSP_IMPL_CFGS_PROG_SCTR_SIZE?1:0);
for ( uint8 itr0 = 0; itr0 < sctr; itr0 += 1 ) {
// PPSP_IMPL_CFGS_PROG_ADDR_BGNS + sctr * 0x1000
ppsp_impl_era_prog_data(PPSP_IMPL_CFGS_PROG_ADDR_BGNS + (itr0<<12));
}
LOG("%s, total sctr:%x@size:%x erased!! \r\n", __func__, sctr, __ppsp_impl_upda_fwsz);
/* resume of last trans point is not supported */
// reset to initial
__ppsp_impl_upda_offs = 0;
__ppsp_impl_upda_wrsz = 0;
__ppsp_impl_upda_dnsz = 0;
__ppsp_impl_upda_crcd = 0xFFFF;
// LOG("%s, pkcs#7=%x\n", __func__, padd);
cipr_text[0] = 0x01; // 1: upda allow, 0: upda deny
osal_memcpy(cipr_text+1, &__ppsp_impl_upda_dnsz, sizeof(__ppsp_impl_upda_dnsz));
// text[1] = 0x00; // last upda posi
// text[2] = 0x00; // last upda posi
// text[3] = 0x00; // last upda posi
// text[4] = 0x00; // last upda posi
cipr_text[5] = 0x0F; // maxi frame in pack(0x00~0x0f:1~16)
text_size = sizeof(cipr_text);
padd_offs = 6;
uint8 cipr[16];
if ( 0x01 == encr ) {
ppsp_impl_get_pkcs_7pad(text_size, padd_offs, padd_valu);
osal_memset(cipr_text+padd_offs, padd_valu, text_size-padd_offs);
ppsp_impl_enc_text(cipr_text, cipr);
}
uint8* xfer;
if ( 0x01 == encr ) {
xfer = ppsp_impl_new_msgs_resp(msgn, PPSP_IMPL_CFGS_OPCO_UPDA_RESP, cipr, sizeof(cipr));
} else {
xfer = ppsp_impl_new_msgs_resp(msgn, PPSP_IMPL_CFGS_OPCO_UPDA_RESP, cipr_text, padd_offs);
}
ppsp_impl_set_msgs_encr(xfer, encr);
if ( 0 != xfer ) ppsp_impl_psh_msgs_xfer(xfer, 20);
RSLT_FAIL_FWSZ:
RSLT_FAIL_MESG:
}
static void
ppsp_impl_prc_msgs_pack(uint8* msgs)
{
uint8 msgn;
uint8 encr;
uint8 alln;
uint8 seqn;
uint8 frsz; // payload size in byte
uint8* plds; // payloads
ppsp_impl_get_msgs_numb(msgs, msgn);
ppsp_impl_get_msgs_encr(msgs, encr);
ppsp_impl_get_msgs_seqn(msgs, alln, seqn);
ppsp_impl_get_msgs_frsz(msgs, frsz);
ppsp_impl_get_msgs_plds(msgs, plds);
// if ( 0x01 == encr || 0x10 != frsz ) {
// LOG("%s, !! INVALID MESG CONTENT !!");
// goto RSLT_FAIL_MESG;
// }
// TODO: HANDLE EXCEPTION OF FRAME LOSS, IN THAT CASE, LAST FRAME NUMB SHOULD RESP FOR RETRANSMITION
/*
* copy offset of this received frame, data copy upto the offset would be copied to a buffer.
* when the buffer is full, data in this buffer should write into flash right a way.
* above procedure could repeat untill all data of the frame, being write into flash.
*/
uint16 offs = 0;
while ( offs < frsz ) {
uint16 size = MIN(sizeof(__ppsp_impl_upda_buff)-__ppsp_impl_upda_offs, frsz-offs);
osal_memcpy(__ppsp_impl_upda_buff+__ppsp_impl_upda_offs, plds+offs, size);
__ppsp_impl_upda_offs += size;
offs += size;
if ( sizeof(__ppsp_impl_upda_buff) == __ppsp_impl_upda_offs ) {
// flsh pack
uint32 dwrd = (__ppsp_impl_upda_offs/sizeof(uint32)) + (__ppsp_impl_upda_offs%sizeof(uint32)?1:0);
for ( int itr0 = 0; itr0 < dwrd; itr0 += 1 ) {
uint32 valw, valr;
// push for write
ppsp_impl_psh_prog_data(
PPSP_IMPL_CFGS_PROG_ADDR_BGNS + __ppsp_impl_upda_wrsz + (itr0 * sizeof(uint32)),
valw = *((uint32*)__ppsp_impl_upda_buff + itr0));
}
// __ppsp_impl_upda_crcd = ppsp_impl_cal_crc16_CCITT_FALSE(__ppsp_impl_upda_crcd, __ppsp_impl_upda_buff, __ppsp_impl_upda_offs);
__ppsp_impl_upda_wrsz += __ppsp_impl_upda_offs;
__ppsp_impl_upda_offs = 0;
}
}
__ppsp_impl_upda_dnsz += frsz;
LOG("%s, crci:%04x, dnsz:%08x \r\n", __func__, __ppsp_impl_upda_crcd, __ppsp_impl_upda_dnsz);
if ( alln != seqn ) {
goto RSLT_SKIP_MESG;
}
/* complete of a package, should resp rcvd seqn, rcvd size */
uint8 cipr_text[16], text_size, padd_offs, padd_valu; // plain text, text size, offset, padding byte;
cipr_text[0] = ((alln&0x0F)<<4)|((seqn&0x0F)<<0); //
osal_memcpy(cipr_text+1, &__ppsp_impl_upda_dnsz, sizeof(__ppsp_impl_upda_dnsz));
// text[1] = 0x00; // last upda posi
// text[2] = 0x20; // last upda posi
// text[3] = 0x00; // last upda posi
// text[4] = 0x00; // last upda posi
text_size = sizeof(cipr_text);
padd_offs = 5;
uint8 cipr_data[16];
uint8 auth;
ppsp_impl_get_auth_rslt(auth);
if ( auth ) {
ppsp_impl_get_pkcs_7pad(text_size, padd_offs, padd_valu);
osal_memset(cipr_text, padd_valu, text_size-padd_offs);
ppsp_impl_enc_text(cipr_text, cipr_data);
}
uint8* xfer;
if ( auth ) {
xfer = ppsp_impl_new_msgs_resp(msgn, PPSP_IMPL_CFGS_OPCO_PACK_RESP, cipr_data, sizeof(cipr_data));
} else {
xfer = ppsp_impl_new_msgs_resp(msgn, PPSP_IMPL_CFGS_OPCO_PACK_RESP, cipr_text, padd_offs);
}
ppsp_impl_set_msgs_encr(xfer, auth);
if ( 0 != xfer ) ppsp_impl_psh_msgs_xfer(xfer, 20);
RSLT_FAIL_MESG:
RSLT_SKIP_MESG:
}
static void
ppsp_impl_prc_msgs_comp(uint8* msgs)
{
uint8 msgn;
uint8 encr;
uint8 frsz;
uint8* plds;
ppsp_impl_get_msgs_numb(msgs, msgn);
ppsp_impl_get_msgs_encr(msgs, encr);
ppsp_impl_get_msgs_frsz(msgs, frsz);
ppsp_impl_get_msgs_plds(msgs, plds);
if ( (0x01 == encr && 0x10 != frsz) || (0x00 == encr && 0x01 != frsz) ) {
LOG("%s, !! INVALID MESG CONTENT !! \r\n", __func__);
goto RSLT_FAIL_MESG;
}
uint8 cipr_text[16], text_size, padd_offs, padd_valu; // plain text, text size, offset, padding byte;
if ( 0x01 == encr ) {
ppsp_impl_dec_cipr(cipr_text, plds);
} else {
osal_memcpy(cipr_text, plds, frsz);
}
if ( 0x01 != cipr_text[0] ) {
LOG("%s, !! INVALID MESG CONTENT !! \r\n", __func__);
goto RSLT_FAIL_MESG;
}
// flsh remains in buffer
if ( 0 < __ppsp_impl_upda_offs ) {
// flsh pack
uint32 dwrd = (__ppsp_impl_upda_offs/sizeof(uint32)) + (__ppsp_impl_upda_offs%sizeof(uint32)?1:0);
for ( int itr0 = 0; itr0 < dwrd; itr0 += 1 ) {
uint32 valw, valr;
// push for write
ppsp_impl_psh_prog_data(
PPSP_IMPL_CFGS_PROG_ADDR_BGNS + __ppsp_impl_upda_wrsz + (itr0 * sizeof(uint32)),
valw = *((uint32*)__ppsp_impl_upda_buff + itr0));
}
// __ppsp_impl_upda_crcd = ppsp_impl_cal_crc16_CCITT_FALSE(__ppsp_impl_upda_crcd, __ppsp_impl_upda_buff, __ppsp_impl_upda_offs);
__ppsp_impl_upda_wrsz += __ppsp_impl_upda_offs;
__ppsp_impl_upda_offs = 0;
}
/* complete of bins, should calc crc16 */
__ppsp_impl_upda_crcd = 0xffff;
for ( int itr0 = 0; itr0 < __ppsp_impl_upda_fwsz; itr0++ ) {
uint8 valu;
memcpy(&valu, (uint8_t*)(PPSP_IMPL_CFGS_PROG_ADDR_BASE+PPSP_IMPL_CFGS_PROG_ADDR_BGNS+itr0), 1);
__ppsp_impl_upda_crcd = ppsp_impl_cal_crc16_CCITT_FALSE(__ppsp_impl_upda_crcd, &valu, 1);
}
LOG("%s, crci:%04x, dnsz:%08x, fwsz:%08x \r\n", __func__, __ppsp_impl_upda_crcd, __ppsp_impl_upda_dnsz, __ppsp_impl_upda_fwsz);
//printf("%s, crci:%04x, dnsz:%08x, fwsz:%08x \n", __func__, __ppsp_impl_upda_crcd, __ppsp_impl_upda_dnsz, __ppsp_impl_upda_fwsz);
/* complete of bins, should write tags for bldr */
// uint32 tags;
// osal_memcpy(&tags, "OTAF", 4);
ppsp_impl_psh_prog_data(PPSP_IMPL_CFGS_PROG_ADDR_BGNS, 0x4641544f); // tag:"OTAF"
// printf("%s, tags:%x \r\n", __func__, tags);
// osal_memset(&tags, 0xFF, 4);
// ppsp_impl_pul_prog_data(PPSP_IMPL_CFGS_PROG_ADDR_BGNS,&tags);
// printf("%s, tags:%x \r\n", __func__, tags);
/* complete of bins, should resp crcs chck */
cipr_text[0] = ((__ppsp_impl_upda_crcd == __ppsp_impl_upda_crcs) ? 0x01 : 0x00); //1:succ, 0:fail
LOG("%s, complete of bins: crcs comp:%s \r\n", __func__, cipr_text[0]?"SUCC": "FAIL");
//printf("%s, complete of bins: crcs comp:%s \n", __func__, cipr_text[0]?"SUCC": "FAIL");
text_size = sizeof(cipr_text);
padd_offs = 1;
uint8 cipr_data[16];
if ( 0x01 == encr ) {
ppsp_impl_get_pkcs_7pad(text_size, padd_offs, padd_valu);
osal_memset(cipr_text, padd_valu, text_size-padd_offs);
ppsp_impl_enc_text(cipr_text, cipr_data);
}
uint8* xfer;
if ( 0x01 == encr ) {
xfer = ppsp_impl_new_msgs_resp(msgn, PPSP_IMPL_CFGS_OPCO_COMP_RESP, cipr_data, sizeof(cipr_data));
} else {
xfer = ppsp_impl_new_msgs_resp(msgn, PPSP_IMPL_CFGS_OPCO_COMP_RESP, cipr_text, padd_offs);
}
ppsp_impl_set_msgs_encr(xfer, encr);
if ( 0 != xfer ) ppsp_impl_psh_msgs_xfer(xfer, 20);
__ppsp_impl_stat_bits_flag |= PPSP_IMPL_CFGS_OTAS_STAT_BITS;
__ppsp_impl_proc_tout_coun = 10; // 1secs
RSLT_FAIL_MESG:
}
static void
ppsp_impl_prc_msgs_user(uint8* msgs_rcvd)
{
uint8 msgn;
uint8 frsz;
uint8* plds;
ppsp_impl_get_msgs_numb(msgs_rcvd, msgn);
ppsp_impl_get_msgs_frsz(msgs_rcvd, frsz);
ppsp_impl_get_msgs_plds(msgs_rcvd, plds);
if ( NULL == plds || 0 >= frsz ) goto RSLT_FAIL_NULL;
/* do whatever user wants */
//tbrsh_leds_gpio_set_mode(TBRSH_LEDS_ENUM_LED1, plds[0]);
//tbrsh_leds_gpio_set_mode(TBRSH_LEDS_ENUM_LED2, plds[0]);
//tbrsh_leds_gpio_set_mode(TBRSH_LEDS_ENUM_LED3, plds[0]);
//tbrsh_motr_pwms_set_valu(30);
//tbrsh_motr_pwms_set_mode(plds[0]);
/* do whatever user wants */
uint8* xfer = 0;
plds[0] = 0x01; // set resp of true
xfer = ppsp_impl_new_msgs_resp(msgn, PPSP_IMPL_CFGS_OPCO_BKEY_RESP, plds, frsz);
if ( NULL == xfer ) goto RSLT_FAIL_NMEM;
ppsp_impl_psh_msgs_xfer(xfer, 20);
RSLT_FAIL_NMEM:
RSLT_FAIL_NULL:
}
static uint8
ppsp_impl_pop_msgs_rcvd(void)
{
uint8 rslt = 0;
uint8* mesg = NULL;
rslt = core_sque_pop(__ppsp_impl_msgs_queu_rcvd, &mesg);
/* */
if ( 1 == rslt ) {
uint8 opco;
ppsp_impl_get_msgs_opco(mesg, opco);
LOG("[PANDA][ERR] ppsp_impl_get_msgs_opco: %02x\n\r", opco);
if ( PPSP_IMPL_CFGS_OPCO_RAND_ISSU == opco ) {
//printf("[PANDA][ERR] ppsp_impl_get_msgs_opco: %02x\n\r", opco);
ppsp_impl_prc_msgs_rand(mesg);
} else
if ( PPSP_IMPL_CFGS_OPCO_VERF_ISSU == opco ) {
//printf("[PANDA][ERR] ppsp_impl_get_msgs_opco: %02x\n\r", opco);
ppsp_impl_prc_msgs_verf(mesg);
} else
if ( PPSP_IMPL_CFGS_OPCO_NWRK_ISSU == opco ) {
//printf("[PANDA][ERR] ppsp_impl_get_msgs_opco: %02x\n\r", opco);
ppsp_impl_prc_msgs_nwrk(mesg);
} else
if ( PPSP_IMPL_CFGS_OPCO_VERS_ISSU == opco ) {
//printf("[PANDA][ERR] ppsp_impl_get_msgs_opco: %02x\n\r", opco);
ppsp_impl_prc_msgs_vers(mesg);
} else
if ( PPSP_IMPL_CFGS_OPCO_UPDA_ISSU == opco ) {
//printf("[PANDA][ERR] ppsp_impl_get_msgs_opco: %02x\n\r", opco);
ppsp_impl_prc_msgs_upda(mesg);
} else
if ( PPSP_IMPL_CFGS_OPCO_PACK_ISSU == opco ) {
ppsp_impl_prc_msgs_pack(mesg);
} else
if ( PPSP_IMPL_CFGS_OPCO_COMP_ISSU == opco ) {
//printf("[PANDA][ERR] ppsp_impl_get_msgs_opco: %02x\n\r", opco);
ppsp_impl_prc_msgs_comp(mesg);
} else
if ( PPSP_IMPL_CFGS_OPCO_USER_ISSU == opco ) {
ppsp_impl_prc_msgs_user(mesg);
}
osal_mem_free(mesg);
}
return ( rslt );
}
static void
ppsp_impl_serv_rcvd_hdlr(uint8 para, uint8 coun)
{
// LOG("[PANDA][ENT] %s para:%d, coun:%d \r\n", __func__, para, coun);
if ( PPSP_SERV_CFGS_CHAR_FFD5_INDX == para ||
PPSP_SERV_CFGS_CHAR_FFD7_INDX == para ) {
void* data = NULL;
if ( NULL == (data = osal_mem_alloc(coun)) ) return;
ppsp_serv_get_para(para, data, coun);
ppsp_impl_psh_msgs_rcvd(data, coun);
ppsp_impl_pop_msgs_rcvd();
if ( NULL != data ) osal_mem_free(data);
}
}
/* alia: ppsp_impl_pop_msgs_xfer */
static void
ppsp_impl_serv_xfer_hdlr(void)
{
// LOG("[PANDA][ENT] %s \r\n", __func__);
uint8 rslt = 1;
uint8* mesg = NULL;
uint8 opco = 0;
uint8 frsz = 0;
rslt = core_sque_pop(__ppsp_impl_msgs_queu_xfer, &mesg);
if ( 1 == rslt ) {
ppsp_impl_get_msgs_opco(mesg, opco);
ppsp_impl_get_msgs_frsz(mesg, frsz);
if ( PPSP_IMPL_CFGS_OPCO_VERS_ISSU <= opco && PPSP_IMPL_CFGS_OPCO_COMP_RESP >= opco )
ppsp_serv_set_para(PPSP_SERV_CFGS_CHAR_FFD8_INDX, frsz + PPSP_IMPL_CFGS_MSGS_HDER_SIZE, (void*)mesg);
else
ppsp_serv_set_para(PPSP_SERV_CFGS_CHAR_FFD6_INDX, frsz + PPSP_IMPL_CFGS_MSGS_HDER_SIZE, (void*)mesg);
osal_mem_free(mesg);
}
}
void
ppsp_impl_appl_timr_hdlr(void)
{
ppsp_impl_serv_xfer_hdlr();
if ( __ppsp_impl_stat_bits_flag & PPSP_IMPL_CFGS_OTAS_STAT_BITS ) {
if ( 0 < __ppsp_impl_proc_tout_coun ) {
__ppsp_impl_proc_tout_coun --;
if ( 0 == __ppsp_impl_proc_tout_coun ) {
//printf("%s, hal_system_soft_reset for bgns of otas \r\n");
write_reg(0x4000f034, 'O'); // flag as an OTAs auto reset
hal_system_soft_reset();
}
}
}/* else
if ( __ppsp_impl_stat_bits_flag & PPSP_IMPL_CFGS_OTAE_STAT_BITS ) {
if ( 0 < __ppsp_impl_proc_tout_coun ) {
__ppsp_impl_proc_tout_coun --;
if ( 0 == __ppsp_impl_proc_tout_coun ) {
printf("%s, hal_system_soft_reset for ends of otas \r\n");
// write_reg(0x4000f034, 'O'); // flag as an OTAs auto reset
hal_system_soft_reset();
}
}
} */
}
uint8
ppsp_impl_ini(void)
{
__ppsp_impl_stat_bits_flag = 0x00;
uint32 regs = read_reg(0x4000f034);
if ( 'O' == regs ) {
write_reg(0x4000f034, 0); // flag as an OTAs auto reset
__ppsp_impl_stat_bits_flag |= PPSP_IMPL_CFGS_OTAE_STAT_BITS;
// __ppsp_impl_proc_tout_coun = 300; // 30secs
}
__ppsp_impl_msgs_queu_rcvd = core_sque_new(sizeof(uint8*), 32);
__ppsp_impl_msgs_queu_xfer = core_sque_new(sizeof(uint8*), 32);
ppsp_serv_add_serv(PPSP_SERV_CFGS_SERV_FEB3_MASK);
ppsp_serv_reg_appl(&__ppsp_impl_hdlr_serv);
LOG("\r\n %s, ALIS VERS NUMB: %02d.%02d.%02d \r\n",
__func__, PPSP_IMPL_CFGS_PROG_VERS_MAJR, PPSP_IMPL_CFGS_PROG_VERS_MINR, PPSP_IMPL_CFGS_PROG_VERS_REVI);
}
uint32
ppsp_impl_get_stat(void)
{
return ( __ppsp_impl_stat_bits_flag );
}
uint8
ppsp_impl_get_pids(uint8* pids)
{
uint8 rslt = 1;
if ( NULL != pids ) {
// load PID
for ( uint8 itr0 = 0; itr0 < PPSP_IMPL_CFGS_ALIS_PIDS_COUN; itr0 += 1 ) {
pids[PPSP_IMPL_CFGS_ALIS_PIDS_COUN-itr0-1] = (uint8_t)ReadFlash(0x4030+itr0);
}
}
return ( rslt );
}
uint8
ppsp_impl_get_macs(uint8* macs)
{
uint8 rslt = 1;
uint32 addr = 0x4000;
if ( NULL != macs ) {
// load MAC
macs [3] = (uint8)ReadFlash(addr ++);
macs [2] = (uint8)ReadFlash(addr ++);
macs [1] = (uint8)ReadFlash(addr ++);
macs [0] = (uint8)ReadFlash(addr ++);
macs [5] = (uint8)ReadFlash(addr ++);
macs [4] = (uint8)ReadFlash(addr);
}
return ( rslt );
}
uint8
ppsp_impl_get_scrt(uint8* scrt)
{
uint8 rslt = 1;
if ( NULL != scrt ) {
for ( uint8 itr0 = 0; itr0 < PPSP_IMPL_CFGS_ALIS_SCRT_COUN; itr0 ++ ) {
scrt[itr0] = (uint8_t)ReadFlash(0x4010+itr0);
}
}
return ( rslt );
}
/* calc auth keys */
uint8
ppsp_impl_cal_keys(const uint8* rand, uint8 rsiz, const uint8* pids, uint8 psiz, const uint8* macs, uint8 msiz, const uint8* scrt, uint8 ssiz)
{
uint8 rslt = 1;
#if 0
gen_aligenie_auth_key((uint8*)rand, rsiz, (uint8*)pids, psiz, (uint8*)macs, msiz, (uint8*)scrt, ssiz);
cpy_aligenie_auth_key(__ppsp_impl_auth_keys_data);
#endif
return ( rslt );
}
uint8
ppsp_impl_get_keys(uint8* keys)
{
uint8 rslt = 0;
if ( NULL == keys ) {
rslt = 0;
goto RSLT_FAIL_NULL;
}
osal_memcpy(keys, __ppsp_impl_auth_keys_data, sizeof(__ppsp_impl_auth_keys_data));
rslt = 1;
RSLT_FAIL_NULL:
return ( rslt );
}
uint8
ppsp_impl_enc_text(uint8* text, uint8* cipr)
{
uint8 rslt = 1;
uint8 iv[16] = { 0x31, 0x32, 0x33, 0x61, 0x71, 0x77, 0x65, 0x64,
0x23, 0x2a, 0x24, 0x21, 0x28, 0x34, 0x6a, 0x75, };
uint8 data[16];
uint8 itr0 = 0;
osal_memcpy(data, text, 16);
while ( itr0 < 16 ) {
data[itr0] ^= iv[itr0];
itr0 += 1;
}
struct tc_aes_key_sched_struct s;
if ( 0 == tc_aes128_set_encrypt_key(&s, __ppsp_impl_auth_keys_data) ) {
LOG("AES128 %s (NIST encr test) failed.\n", __func__);
rslt = 0;
goto RSLT_FAIL_ENCR;
}
if (tc_aes_encrypt(cipr, data, &s) == 0) {
LOG("AES128 %s (NIST encr test) failed.\n", __func__);
rslt = 0;
goto RSLT_FAIL_ENCR;
}
rslt = 1;
RSLT_FAIL_ENCR:
return ( rslt );
}
uint8
ppsp_impl_dec_cipr(uint8* text, uint8* cipr)
{
uint8 rslt = 1;
struct tc_aes_key_sched_struct s;
if (0 == tc_aes128_set_decrypt_key(&s, __ppsp_impl_auth_keys_data) ) {
LOG("AES128 %s (NIST decr test) failed.\n", __func__);
rslt = 0;
goto RSLT_FAIL_ENCR;
}
if (tc_aes_decrypt(text, cipr, &s) == 0) {
LOG("AES128 %s (NIST decr test) failed.\n", __func__);
rslt = 0;
goto RSLT_FAIL_ENCR;
}
uint8 aesiv[16] = { 0x31, 0x32, 0x33, 0x61, 0x71, 0x77, 0x65, 0x64,
0x23, 0x2a, 0x24, 0x21, 0x28, 0x34, 0x6a, 0x75, };
uint8 itr0 = 0;
while ( itr0 < 16 ) {
text[itr0] ^= aesiv[itr0];
itr0 += 1;
}
rslt = 1;
RSLT_FAIL_ENCR:
return ( rslt );
}
/*
* callback of connection stat changes
*/
void
ppsp_impl_ack_conn(uint8 flag)
{
// /* this likely a disconnection after OTAs, reset is required for complete */
// if ( __ppsp_impl_stat_bits_flag & PPSP_IMPL_CFGS_OTAS_STAT_BITS ) {
// write_reg(0x4000f034, 'O'); // flag as an OTAs auto reset
// hal_system_soft_reset();
// }
// // connection loss, shold reset all status
// __ppsp_impl_stat_bits_flag = 0x00;
}