Index: BT_doublebyte/sdk/Librarier/sdk/iic.h =================================================================== --- /YC3121_demo/ModuleDemo/BlueTooth/BT_doublebyte/sdk/Librarier/sdk/iic.h (nonexistent) +++ /YC3121_demo/ModuleDemo/BlueTooth/BT_doublebyte/sdk/Librarier/sdk/iic.h (working copy) @@ -0,0 +1,18 @@ +#ifndef _IIC_H_ +#define _IIC_H_ + +#define IIC_NACK 0 +#define IIC_ACK 1 + +#define IIC_WAIT_ACK_COUNT 256 + +void IIC_Start(void); +void IIC_Stop(void); +char IIC_WaitAck(void); +void IIC_SendAck(unsigned char ackbit); +char IIC_SendByte(unsigned char byt); +unsigned char IIC_RecByte(void); +char IIC_SendData(unsigned char *Src, unsigned short len); +//char IIC_ReceiveData(unsigned char *Src, unsigned short Srclen, unsigned char *Dest, unsigned short Destlen); + +#endif Index: BT_doublebyte/sdk/Librarier/sdk/iic.c =================================================================== --- /YC3121_demo/ModuleDemo/BlueTooth/BT_doublebyte/sdk/Librarier/sdk/iic.c (nonexistent) +++ /YC3121_demo/ModuleDemo/BlueTooth/BT_doublebyte/sdk/Librarier/sdk/iic.c (working copy) @@ -0,0 +1,137 @@ +#include "iic.h" +#include "yc3121.h" +#include "yc_gpio.h" + +#define SdaGpio GPIO_Pin_11 +#define SclGpio GPIO_Pin_12 + + +void IIC_SdaHigh(void) +{ + GPIO_WriteBit(GPIOC, SdaGpio, Bit_SET); +} + +void IIC_SdaLow(void) +{ + GPIO_WriteBit(GPIOC, SdaGpio, Bit_RESET); +} + +void IIC_SclHigh(void) +{ + GPIO_WriteBit(GPIOC, SclGpio, Bit_SET); +} + +void IIC_SclLow(void) +{ + GPIO_WriteBit(GPIOC, SclGpio, Bit_RESET); +} + +void IIC_SdaSetInput(void) +{ + GPIO_Config(GPIOC, SdaGpio, INPUT); +} + +unsigned char IIC_SdaGetInput(void) +{ + return GPIO_ReadInputDataBit(GPIOC, SdaGpio); +} + +void IIC_Delay(void) +{ + while(0); +} + +void IIC_Start(void) +{ + IIC_SdaHigh(); + IIC_SclHigh(); + IIC_Delay(); + IIC_SdaLow(); + IIC_Delay(); + IIC_SclLow(); +} + + +void IIC_Stop(void) +{ + IIC_SdaLow(); + IIC_SclHigh(); + IIC_Delay(); +// IIC_SclHigh(); +// IIC_Delay(); + IIC_SdaHigh(); + IIC_Delay(); +} + +//发送应答 +void IIC_SendAck(unsigned char ackbit) +{ + IIC_SclLow(); + (ackbit)? IIC_SdaHigh():IIC_SdaLow(); + IIC_Delay(); + IIC_SclHigh(); + IIC_Delay(); + IIC_SclLow(); + //IIC_SdaHigh(); + //IIC_Delay(); +} + +//等待应答 +char IIC_WaitAck(void) +{ + IIC_SdaSetInput(); + IIC_SclLow(); + IIC_Delay(); + IIC_SclHigh(); + int cnt=0; + while(IIC_SdaGetInput()) + { + cnt++; + IIC_Delay(); + if(cnt>IIC_WAIT_ACK_COUNT) + { + IIC_Stop(); + return 0; + } + }; + IIC_SclLow(); + IIC_Delay(); + return 1; +} + +//通过I2C总线发送数据 +char IIC_SendByte(unsigned char byt) +{ + unsigned char i; + IIC_SclLow(); + for (i = 0; i < 8; i++) { + // IIC_Delay(); + (byt & 0x80)? IIC_SdaHigh():IIC_SdaLow(); + IIC_Delay(); + IIC_SclHigh(); + byt <<= 1; + IIC_Delay(); + IIC_SclLow(); + IIC_Delay(); + } +// IIC_SclLow(); + //IIC_SdaHigh(); + return IIC_WaitAck(); +} + +//从I2C总线上接收数据 +unsigned char IIC_RecByte(void) +{ + unsigned char i, da=0; + IIC_SdaSetInput(); + for (i = 0; i < 8; i++) { + IIC_SclHigh(); + da <<= 1; + if (IIC_SdaGetInput()) + da |= 1; + IIC_Delay(); + IIC_SclLow(); + IIC_Delay(); + } + return da; +} Index: BT_doublebyte/sdk/Librarier/sdk/mfi.h =================================================================== --- /YC3121_demo/ModuleDemo/BlueTooth/BT_doublebyte/sdk/Librarier/sdk/mfi.h (nonexistent) +++ /YC3121_demo/ModuleDemo/BlueTooth/BT_doublebyte/sdk/Librarier/sdk/mfi.h (working copy) @@ -0,0 +1,196 @@ +#ifndef _MFI_H_ +#define _MFI_H_ + +#include "system.h" +#include "mfi_coprocessor.h" + +//#define MFI_EDBUG +#define MFI_RX_BUF_LENTH 1320 + + +#define MFI_IAP2_LINK_PACKET_START_MSB 0xff +#define MFI_IAP2_LINK_PACKET_START_LSB 0x5a + +#define MFI_IAP2_CONTROL_SESSION_ID 0Xa +#define MFI_IAP2_EA_SESSION_ID 0xb + +//control byte +#define MFI_IAP2_SYN_BIT 7 //link synchronization payload is present +#define MFI_IAP2_ACK_BIT 6 //packet acknowledgement number is valid ,and iap2 session payload may be present +#define MFI_IAP2_EAK_BIT 5 //extended acknowledgement payload is present +#define MFI_IAP2_RST_BIT 4 //link reset +#define MFI_IAP2_SLP_BIT 3 //device sleep +#define MFI_IAP2_CONTROL_RST 0x10 +#define MFI_IAP2_CONTR0L_SLP 0x08 + + +#define MFI_IAP2_CONTROL_SESSION_MESSAGE_START_MSB 0x40 +#define MFI_IAP2_CONTROL_SESSION_MESSAGE_START_LSB 0x40 + +#define MFI_IAP2_ACCESSORY_AUTHENTICATION_MSB 0xAA +enum{ + MFI_IAP2_REQUEST_AUTHENTICATION_CERTIFICATE_LSB = 0, + MFI_IAP2_AUTHENTICATION_CERTIFICATE_LSB, + MFI_IAP2_REQUEST_AUTHENTICATION_CHALLENGE_RES_LSB, + MFI_IAP2_AUTHENTICATION_RES_LSB, + MFI_IAP2_AUTHENTICATION_FAILED_LSB, + MFI_IAP2_AUTHENTICATION_SUCCEEDED_LSB, + MFI_IAP2_ACCESSORY_AUTHENTICATION_SERIAL_NUMBER_LSB +}; + +#define MFI_IAP2_ACCESSORY_IDENTIFICATION_MSB 0x1d +enum{ + MFI_IAP2_START_IDENTIFICATION_LSB = 0, + MFI_IAP2_IDENTIFICATION_INFORMATION_LSB=1, + MFI_IAP2_IDENTIFICATION_ACCEPTED_LSB=2, + MFI_IAP2_IDENTIFICATION_REJECTED_LSB=3, + MFI_IAP2_CANCEL_IDENTIFICATION_LSB=5, + MFI_IAP2_IDENTIFICATION_INFORMATION_UPDATE_LSB=6 +}; + +#define MFI_IAP2_EA_PROTOCOL_MSB 0xEA +enum{ + MFI_IAP2_START_EA_PROTOCOL_SESSION_LSB = 0, + MFI_IAP2_STOP_EA_PROTOCOL_SESSION_LSB, + MFI_IAP2_STATUS_EA_PROTOCOL_SESSION_LSB +}; + +enum{ //MFI_IAP2_START_EA_PROTOCOL_SESSION + MFI_IAP2_START_EA_PROTOCOL_ID = 0, + MFI_IAP2_START_EA_PROTOCOL_SESSION_ID +}; + +typedef struct +{ + unsigned char StartMsb; + unsigned char Startlsb; + unsigned char LenMsb; + unsigned char LenLsb; + unsigned char Control; + unsigned char Seq; + unsigned char Ack; + unsigned char SessionId; + unsigned char HeaderCheckSum; + unsigned short PayloadLen; + unsigned char *Payload; + unsigned char PayloadCheckSum; +}IAP2_LinkPacketDef; + +typedef struct +{ +// unsigned char LenMsb; +// unsigned char LenLsb; + unsigned char IdMsb; + unsigned char IdLsb; + unsigned short DataLen; + unsigned char *Data; +}IAP2_ControlMessageParaDef; + +typedef struct +{ + unsigned char StartMsb; + unsigned char StartLsb; +// unsigned char LenMsb; +// unsigned char LenLsb; + unsigned char IdMsb; + unsigned char IdLsb; + unsigned short DataLen; + unsigned char *Data; + unsigned char ParaNumber; + IAP2_ControlMessageParaDef Para[20]; +}IAP2_ControlMessageDef; + + +typedef struct +{ + unsigned char EaStart; + unsigned char EaId; + unsigned short EaSessionId; +}IAP2_EaStateDef; + +typedef struct +{ + unsigned short Len; + unsigned char Buf[MFI_RX_BUF_LENTH]; +}MFI_RxBufDef; + + +enum{ + MFI_IAP2_PACKET_STRUCTURE_START_MSB_OFFSET = 0, + MFI_IAP2_PACKET_STRUCTURE_START_LSB_OFFSET=1, + MFI_IAP2_PACKET_STRUCTURE_LEN_MSB_OFFSET=2, + MFI_IAP2_PACKET_STRUCTURE_LEN_LSB_OFFSET=3, + MFI_IAP2_PACKET_STRUCTURE_CONTROL_OFFSET=4, + MFI_IAP2_PACKET_STRUCTURE_SEQ_OFFSET=5, + MFI_IAP2_PACKET_STRUCTURE_ACK_OFFSET=6, + MFI_IAP2_PACKET_STRUCTURE_SESSION_ID_OFFSET=7, + MFI_IAP2_PACKET_STRUCTURE_HEADER_SUM_OFFSET=8, + MFI_IAP2_PACKET_STRUCTURE_PAYLOAD_DATA_OFFSET=9 +}; + +enum{ + MFI_IAP2_EA_STOP = 0, + MFI_IAP2_EA_START +}; + +typedef enum +{ + MFI_IAP2_SM_NULL=0, + MFI_IAP2_SM_RFCOMM_CONNECTED, + MFI_IAP2_SM_DETECT_IAP2_SUPPORT, + MFI_IAP2_SM_DETECT_IAP2_SUPPORT_WAIT, + MFI_IAP2_SM_NEGOTIATE_LINK_PARAMETERS, + MFI_IAP2_SM_NEGOTIATE_LINK_PARAMETERS_WAIT, + MFI_IAP2_SM_NEGOTIATE_LINK_PARAMETERS_REV, + MFI_IAP2_SM_NEGOTIATE_LINK_PARAMETERS_REV_ACK, + + MFI_IAP2_SM_WAIT_AUTH_PROC= 0x10, + MFI_IAP2_SM_AUTH_PROC_END, + MFI_IAP2_SM_AUTH_SUCCEEDED, + MFI_IAP2_SM_AUTH_FAIL, + + MFI_IAP2_SM_START_IDENTIFICATION= 0x20, + MFI_IAP2_SM_IDENTIFICATION_INFORMATION, + MFI_IAP2_SM_IDENTIFICATION_ACCEPTED, + MFI_IAP2_SM_IDENTIFICATION_REJECTED +}MFI_SM_TYPE; + + +//MFI_IAP2_IDENTIFICATION_INFORMATION ID +#define MFI_IAP2_ID_INFOR_ID_NAME 0 +#define MFI_IAP2_ID_INFOR_ID_MODELIDENTIFIIER 1 +#define MFI_IAP2_ID_INFOR_ID_MANUFACTURER 2 +#define MFI_IAP2_ID_INFOR_ID_SERIAL_NUMBER 3 +#define MFI_IAP2_ID_INFOR_ID_FIRMWARE_VERSION 4 +#define MFI_IAP2_ID_INFOR_ID_HARDWARE_VERSION 5 +#define MFI_IAP2_ID_INFOR_ID_MESSAGES_SENT_BY_ACCESSORY 6 +#define MFI_IAP2_ID_INFOR_ID_MESSAGES_RECV_FROM_DEVICE 7 +#define MFI_IAP2_ID_INFOR_ID_POWER_PROVIDING_CAPABILITY 8 +#define MFI_IAP2_ID_INFOR_ID_MAX_CURRENT_DRAWN_FROM_DEVICE 9 +#define MFI_IAP2_ID_INFOR_ID_SUPPORTED_EA_PROTOCOL 10 +#define MFI_IAP2_ID_INFOR_ID_APP_MATCH_TEAM_ID 11 +#define MFI_IAP2_ID_INFOR_ID_CURRENT_LANGUAGE 12 +#define MFI_IAP2_ID_INFOR_ID_SUPPORTED_LANGUAGE 13 +#define MFI_IAP2_ID_INFOR_ID_BLUETHOOTH_TRANSPORT_COMPONENT 17 + + +// MFI_IAP2_ID_INFOR_ID_SUPPORTED_EA_PROTOCOL +#define MFI_IAP2_ID_INFOR_SUPPORTED_EA_PROTOCOL_ID 0 +#define MFI_IAP2_ID_INFOR_SUPPORTED_EA_PROTOCOL_NAME 1 +#define MFI_IAP2_ID_INFOR_SUPPORTED_EA_PROTOCOL_MATCHACTION 2 + +// MFI_IAP2_ID_INFOR_ID_BLUETHOOTH_TRANSPORT_COMPONENT +#define MFI_IAP2_ID_INFOR_BT_TRANSPORT_COMPONENT_ID 0 +#define MFI_IAP2_ID_INFOR_BT_TRANSPORT_COMPONENT_NAME 1 +#define MFI_IAP2_ID_INFOR_BT_TRANSPORT_COMPONENT_IAP2 2 +#define MFI_IAP2_ID_INFOR_BT_TRANSPORT_COMPONENT_ADDRESS 3 + + +void MFI_Start(void); +void MFI_StateReset(void); +void MFI_SmProcess(void); +unsigned char MFI_CheckSum(unsigned char* data,unsigned int len); +unsigned char MFI_RecData(unsigned char* data,unsigned int len); + +#endif + Index: BT_doublebyte/sdk/Librarier/sdk/mfi.c =================================================================== --- /YC3121_demo/ModuleDemo/BlueTooth/BT_doublebyte/sdk/Librarier/sdk/mfi.c (nonexistent) +++ /YC3121_demo/ModuleDemo/BlueTooth/BT_doublebyte/sdk/Librarier/sdk/mfi.c (working copy) @@ -0,0 +1,734 @@ +#include "mfi.h" + +const unsigned char mfi_detect_data[6]={0xff,0x55,0x02,0x00,0xee,0x10}; +const unsigned char mfi_linkpara_data[16]={0x01,0x03,0x02,0x94,0x05,0xdc,0x03,0xe8,0x1e,0x03,MFI_IAP2_CONTROL_SESSION_ID,0x00,0x01,MFI_IAP2_EA_SESSION_ID,0x02,0x01}; +const unsigned char mfi_info_data[197]={ + 0x00,0x07,0x00,MFI_IAP2_ID_INFOR_ID_MODELIDENTIFIIER,0x4c,0x32,0x00, + 0x00,0x2f,0x00,MFI_IAP2_ID_INFOR_ID_MANUFACTURER,0x58,0x69,0x61,0x6d,0x65,0x6e,0x20,0x48,0x61,0x6e,0x69,0x6e,0x20,0x45,0x6c,0x65,0x63,0x74,0x72,0x6f,0x6e,0x69,0x63,0x20,0x54,0x65,0x63,0x68,0x6e,0x6f,0x6c,0x6f,0x67,0x79,0x20,0x43,0x6f,0x2e,0x2c,0x4c,0x74,0x64,0x00, + 0x00,0x11,0x00,MFI_IAP2_ID_INFOR_ID_SERIAL_NUMBER,0x44,0x39,0x37,0x42,0x38,0x46,0x38,0x32,0x31,0x35,0x30,0x30,0x00, + 0x00,0x08,0x00,MFI_IAP2_ID_INFOR_ID_FIRMWARE_VERSION,0x31,0x30,0x30,0x00, + 0x00,0x08,0x00,MFI_IAP2_ID_INFOR_ID_HARDWARE_VERSION,0x31,0x30,0x30,0x00, + 0x00,0x04,0x00,MFI_IAP2_ID_INFOR_ID_MESSAGES_SENT_BY_ACCESSORY, + 0x00,0x08,0x00,MFI_IAP2_ID_INFOR_ID_MESSAGES_RECV_FROM_DEVICE,0xea,0x00,0xea,0x01, + 0x00,0x05,0x00,MFI_IAP2_ID_INFOR_ID_POWER_PROVIDING_CAPABILITY,0x00, + 0x00,0x06,0x00,MFI_IAP2_ID_INFOR_ID_MAX_CURRENT_DRAWN_FROM_DEVICE,0x00,0x00, + 0x00,0x26,0x00,MFI_IAP2_ID_INFOR_ID_SUPPORTED_EA_PROTOCOL, + 0x00,0x05,0x00,MFI_IAP2_ID_INFOR_SUPPORTED_EA_PROTOCOL_ID,0x05, + 0x00,0x18,0x00,MFI_IAP2_ID_INFOR_SUPPORTED_EA_PROTOCOL_NAME,0x63,0x6f,0x6d,0x2e,0x62,0x72,0x74,0x2e,0x63,0x6f,0x6d,0x2e,0x69,0x62,0x72,0x69,0x64,0x67,0x65,0x00, + 0x00,0x05,0x00,MFI_IAP2_ID_INFOR_SUPPORTED_EA_PROTOCOL_MATCHACTION,0x01, + 0x00,0x07,0x00,MFI_IAP2_ID_INFOR_ID_CURRENT_LANGUAGE,0x7a,0x68,0x00, + 0x00,0x07,0x00,MFI_IAP2_ID_INFOR_ID_SUPPORTED_LANGUAGE,0x7a,0x68,0x00, + 0x00,0x29,0x00,MFI_IAP2_ID_INFOR_ID_BLUETHOOTH_TRANSPORT_COMPONENT, + 0x00,0x06,0x00,MFI_IAP2_ID_INFOR_BT_TRANSPORT_COMPONENT_ID,0x20,0x00, + 0x00,0x11,0x00,MFI_IAP2_ID_INFOR_BT_TRANSPORT_COMPONENT_NAME,0x42,0x54,0x2d,0x54,0x72,0x61,0x6e,0x73,0x70,0x6f,0x72,0x74,0x00, + 0x00,0x04,0x00,MFI_IAP2_ID_INFOR_BT_TRANSPORT_COMPONENT_IAP2, + 0x00,0x0a,0x00,MFI_IAP2_ID_INFOR_BT_TRANSPORT_COMPONENT_ADDRESS +}; + +extern unsigned char *bt_name_ptr; +extern unsigned char bt_name_len; +extern unsigned char bt_addr[6]; + +MFI_RxBufDef mfi_rx_buf = { + .Len = 0 +}; + + +MFI_SM_TYPE mfi_sm = MFI_IAP2_SM_NULL; + +unsigned char mfi_error = 0; +unsigned char mfi_init =0; + +IAP2_EaStateDef ea_state={ + .EaStart = MFI_IAP2_EA_STOP, + .EaId = 0, + .EaSessionId = 0 +}; +IAP2_LinkPacketDef mfi_send_packet={ + .StartMsb = MFI_IAP2_LINK_PACKET_START_MSB, + .Startlsb = MFI_IAP2_LINK_PACKET_START_LSB, + .LenMsb = 0, + .LenLsb = 0, + .Control = 0, + .Seq = 0, + .Ack = 0, + .SessionId = 0, + .HeaderCheckSum = 0, + .PayloadLen = 0, + .Payload = NULL, + .PayloadCheckSum = 0 +}; +IAP2_LinkPacketDef mfi_recv_packet={ + .StartMsb = MFI_IAP2_LINK_PACKET_START_MSB, + .Startlsb = MFI_IAP2_LINK_PACKET_START_LSB, + .LenMsb = 0, + .LenLsb = 0, + .Control = 0, + .Seq = 0, + .Ack = 0, + .SessionId = 0, + .HeaderCheckSum = 0, + .PayloadLen = 0, + .Payload = NULL, + .PayloadCheckSum = 0 +}; + + +void MFI_StateReset(void) +{ + mfi_sm = MFI_IAP2_SM_NULL; + mfi_recv_packet.Seq = 0; + mfi_init =0; + mfi_rx_buf.Len = 0; + ea_state.EaStart = MFI_IAP2_EA_STOP; + +} + +void MFI_Start(void) +{ + mfi_sm = MFI_IAP2_SM_DETECT_IAP2_SUPPORT; +} + + +void MFI_SendData(unsigned char data,unsigned short len) +{ +// unsigned char txbuf[260]={0}; + +} + +void MFI_SendLinkPacket(void ) +{ + unsigned char txbuf[1000]={0}; + unsigned short i; + mfi_send_packet.Ack = mfi_recv_packet.Seq; + if(mfi_send_packet.PayloadLen) + { + mfi_send_packet.Seq ++; + mfi_send_packet.LenLsb = (mfi_send_packet.PayloadLen+10)&0xff; + mfi_send_packet.LenMsb = (mfi_send_packet.PayloadLen+10)>>8; + mfi_send_packet.HeaderCheckSum = MFI_CheckSum((unsigned char*)&mfi_send_packet,8); + mfi_send_packet.PayloadCheckSum = MFI_CheckSum(mfi_send_packet.Payload,mfi_send_packet.PayloadLen); + for(i=0;i<9;i++) + txbuf[i] = (((unsigned char *)&mfi_send_packet))[i]; + for(;iDataLen+4)>>8; + buf[1] = para->DataLen+4; + buf[2] = para->IdMsb; + buf[3] = para->IdLsb; + for(i=0;iDataLen;i++) + buf[i+4] = para->Data[i]; + return i+4; +} + +unsigned short MFI_MessagePack(IAP2_ControlMessageDef *message,unsigned char *buf) +{ + unsigned short i,j; + buf[0] = message->StartMsb; + buf[1] = message->StartLsb; + buf[4] = message->IdMsb; + buf[5] = message->IdLsb; +// for(i=0;iDataLen;i++) +// buf[6+i] = message->Data[i]; + i =6; + for(j=0;jParaNumber;j++) + i += MFI_MessageParaPack(message->Para+j,buf+i); + + buf[2] = i>>8; + buf[3] = i; + return i; +} + + +void MFI_SendMessage(IAP2_ControlMessageDef * message) +{ + unsigned char txbuf[1000] = {0}; + mfi_send_packet.PayloadLen = MFI_MessagePack(message,txbuf); +// if(mfi_send_packet.PayloadLen > sizeof(txbuf)) +// MyPrintf("len error!!!"); + mfi_send_packet.Control = 1<ParaNumber = 0; + while(message->DataLen-offset>0) + { + if((message->Data[offset] <<8) +message->Data[offset+1] <= message->DataLen ) + { + message->Para[message->ParaNumber].IdMsb = message->Data[offset+2]; + message->Para[message->ParaNumber].IdLsb = message->Data[offset+3]; + message->Para[message->ParaNumber].Data = message->Data+offset+4; + message->Para[message->ParaNumber].DataLen = (message->Data[offset]<<8)+ message->Data[offset+1] -4 ; + +#ifdef MFI_EDBUG + MyPrintf("ParaNumber %x %x:\n",message->ParaNumber,message->DataLen); + MyPrintf("len %x:",message->Para[message->ParaNumber].DataLen); + for( i =0; i Para[message->ParaNumber].DataLen;i++) + MyPrintf("%02x ",message->Para[message->ParaNumber].Data[i]); MyPrintf("\n") ; +#endif + offset += message->Para[message->ParaNumber].DataLen + 4 ; + if(message->ParaNumber++ >=20) + break; + } + else + return 0; + } + return 1; +} + +void MFI_SendAuthChallengeRes(IAP2_ControlMessageDef * message) +{ + int i; + if(!MFI_MessageParaResolve(message) ) + return ; + for(i=0;iParaNumber ;i++) + { + if(message->Para[i].IdLsb == 0 && message->Para[i].IdMsb == 0) + { + MFICP_WriteChallengeDataLen(message->Para[i].DataLen); + MFICP_WriteChallengeData(message->Para[i].Data); + MFICP_WriteStatusProcControl(); + mfi_sm = MFI_IAP2_SM_WAIT_AUTH_PROC; + break; + } + } +} + +void MFI_WaitAuth(void) +{ + unsigned char status; + unsigned char chellenge[MFICP_LEN_CHALLENGE_RES_DATA]= {0}; + IAP2_ControlMessageDef message_send; + delay_us(500); + if(MFICP_CheckActive()) + { + mfi_sm = MFI_IAP2_SM_AUTH_PROC_END; +// delay_us(500); + if(MFICP_ReadAuthStatus(&status)) + { + if(status & 0x10) + { + if(MFICP_ReadChellengeResDataLen()== MFICP_LEN_CHALLENGE_RES_DATA) + { + MFICP_ReadChellengeResData(chellenge); + message_send.ParaNumber = 1; + message_send.Para[0].IdLsb = 0; + message_send.Para[0].IdMsb = 0; + message_send.Para[0].DataLen = MFICP_LEN_CHALLENGE_RES_DATA; + message_send.Para[0].Data = chellenge; + + message_send.StartMsb = MFI_IAP2_CONTROL_SESSION_MESSAGE_START_MSB; + message_send.StartLsb = MFI_IAP2_CONTROL_SESSION_MESSAGE_START_LSB; + message_send.IdLsb = MFI_IAP2_AUTHENTICATION_RES_LSB; + message_send.IdMsb = MFI_IAP2_ACCESSORY_AUTHENTICATION_MSB; + MFI_SendMessage(&message_send); + } + } + else + ;//auth fail + } + } +} + +void MFI_SmProcess(void) +{ + switch(mfi_sm) + { + case MFI_IAP2_SM_NULL: + break; + case MFI_IAP2_SM_RFCOMM_CONNECTED: + break; + + case MFI_IAP2_SM_DETECT_IAP2_SUPPORT: + mfi_sm = MFI_IAP2_SM_DETECT_IAP2_SUPPORT_WAIT; + Bt_CmdSenddata((unsigned char*)mfi_detect_data,6); + break; + + case MFI_IAP2_SM_DETECT_IAP2_SUPPORT_WAIT: + break; + case MFI_IAP2_SM_NEGOTIATE_LINK_PARAMETERS: + mfi_sm = MFI_IAP2_SM_NEGOTIATE_LINK_PARAMETERS_WAIT; + MFI_SendLinkPara(); + break; + + case MFI_IAP2_SM_NEGOTIATE_LINK_PARAMETERS_WAIT: + break; + case MFI_IAP2_SM_NEGOTIATE_LINK_PARAMETERS_REV: + break; + case MFI_IAP2_SM_NEGOTIATE_LINK_PARAMETERS_REV_ACK: + break; + case MFI_IAP2_SM_WAIT_AUTH_PROC: + MFI_WaitAuth(); + break; + case MFI_IAP2_SM_AUTH_PROC_END: + break; + case MFI_IAP2_SM_AUTH_SUCCEEDED: + break; + case MFI_IAP2_SM_START_IDENTIFICATION: + break; + case MFI_IAP2_SM_IDENTIFICATION_INFORMATION: + break; + case MFI_IAP2_SM_IDENTIFICATION_ACCEPTED: + break; + case MFI_IAP2_SM_IDENTIFICATION_REJECTED: + break; + default: + break; + } +} + +unsigned char MFI_CheckSum(unsigned char* data,unsigned int len) +{ + unsigned int i; + unsigned char sum=0; + for(i=0;iIdLsb) + { + case MFI_IAP2_REQUEST_AUTHENTICATION_CERTIFICATE_LSB : + MFI_SendAuthCert(); + break; + case MFI_IAP2_AUTHENTICATION_CERTIFICATE_LSB: + break; + case MFI_IAP2_REQUEST_AUTHENTICATION_CHALLENGE_RES_LSB: + MFI_SendAuthChallengeRes(message); + break; + case MFI_IAP2_AUTHENTICATION_RES_LSB: + break; + case MFI_IAP2_AUTHENTICATION_FAILED_LSB: + mfi_sm = MFI_IAP2_SM_AUTH_FAIL; + break; + case MFI_IAP2_AUTHENTICATION_SUCCEEDED_LSB: + mfi_sm = MFI_IAP2_SM_AUTH_SUCCEEDED; + break; + case MFI_IAP2_ACCESSORY_AUTHENTICATION_SERIAL_NUMBER_LSB : + break; + } +} + +void MFI_RecIap2StartIdentification(void) +{ + unsigned char txbuf[1000] = {0}; + int i,j; + txbuf[0] = MFI_IAP2_CONTROL_SESSION_MESSAGE_START_MSB; + txbuf[1] = MFI_IAP2_CONTROL_SESSION_MESSAGE_START_LSB; + txbuf[4] = MFI_IAP2_ACCESSORY_IDENTIFICATION_MSB; + txbuf[5] = MFI_IAP2_IDENTIFICATION_INFORMATION_LSB; + + txbuf[6] = (bt_name_len+1+4)>>8; + txbuf[7] = bt_name_len+1+4; + txbuf[8] = MFI_IAP2_ID_INFOR_ID_NAME>>8; + txbuf[9] = MFI_IAP2_ID_INFOR_ID_NAME; + for(j=0,i=10;j>8; + txbuf[3] = i; + + mfi_send_packet.Control = 1<IdLsb) + { + case MFI_IAP2_START_IDENTIFICATION_LSB : + mfi_sm = MFI_IAP2_SM_START_IDENTIFICATION; + MFI_RecIap2StartIdentification(); + break; + case MFI_IAP2_IDENTIFICATION_INFORMATION_LSB: + break; + case MFI_IAP2_IDENTIFICATION_ACCEPTED_LSB: + mfi_sm = MFI_IAP2_SM_IDENTIFICATION_ACCEPTED; + break; + case MFI_IAP2_IDENTIFICATION_REJECTED_LSB: + mfi_sm = MFI_IAP2_SM_IDENTIFICATION_REJECTED; + break; + case MFI_IAP2_CANCEL_IDENTIFICATION_LSB: + break; + case MFI_IAP2_IDENTIFICATION_INFORMATION_UPDATE_LSB: + break; + } +} + +void MFI_RecIap2EaProtocolStart(IAP2_ControlMessageDef * message) +{ + unsigned char i; + if(!MFI_MessageParaResolve(message) ) + return; +#ifdef MFI_EDBUG + MyPrintf("==== EA START ====\n "); +#endif // MFI_EDBUG + for(i=0;iParaNumber ;i++) + { + switch(message->Para[i].IdLsb + (message->Para[i].IdMsb<<8)) + { + case MFI_IAP2_START_EA_PROTOCOL_ID: + ea_state.EaStart = MFI_IAP2_EA_START; + ea_state.EaId = message->Para[i].Data[0]; + break; + case MFI_IAP2_START_EA_PROTOCOL_SESSION_ID: + ea_state.EaSessionId = (message->Para[i].Data[0]<<8)+message->Para[i].Data[1]; + break; + } + } +} + +void MFI_RecIap2EaProtocolStop(IAP2_ControlMessageDef * message) +{ + unsigned char i; + if(!MFI_MessageParaResolve(message) ) + return; +#ifdef MFI_EDBUG + MyPrintf("==== EA STOP ====\n "); +#endif // MFI_EDBUG + for(i=0;iParaNumber ;i++) + { + if(0 == message->Para[i].IdLsb + (message->Para[i].IdMsb<<8) + && ea_state.EaSessionId == (message->Para[i].Data[0]<<8)+message->Para[i].Data[1] + && message->Para[i].DataLen == 2 ) + { + ea_state.EaStart = MFI_IAP2_EA_STOP; + ea_state.EaId = 0; + ea_state.EaSessionId = 0; +#ifdef MFI_EDBUG + MyPrintf("Session ID:%x\n ",(message->Para[i].Data[0]<<8)+message->Para[i].Data[1]); +#endif + } + } +} + +void MFI_RecIap2EaProtocol(IAP2_ControlMessageDef * message) +{ + switch(message->IdLsb) + { + case MFI_IAP2_START_EA_PROTOCOL_SESSION_LSB : + MFI_RecIap2EaProtocolStart(message); + break; + case MFI_IAP2_STOP_EA_PROTOCOL_SESSION_LSB: + MFI_RecIap2EaProtocolStop(message); + break; + case MFI_IAP2_STATUS_EA_PROTOCOL_SESSION_LSB: + break; + } +} + +void MFI_SendIap2EaPacket(unsigned char *data,unsigned short len) +{ + int i,j; + unsigned char txbuf[1000] ; + if(ea_state.EaStart == MFI_IAP2_EA_START && len>0 ) + { + mfi_send_packet.Control = 1<>8; + mfi_send_packet.HeaderCheckSum = MFI_CheckSum((unsigned char*)&mfi_send_packet,8); + + for(i=0;i<9;i++) + txbuf[i] = (((unsigned char *)&mfi_send_packet))[i]; + + txbuf[9] = ea_state.EaSessionId>>8; + txbuf[10] = ea_state.EaSessionId; + i+=2; + for(j=0;j RX Ea len %x:\n EA data:",mfi_recv_packet.PayloadLen-2); +// for(int i =0; i < mfi_recv_packet.PayloadLen-2;i++) +// MyPrintf(" %02x",mfi_recv_packet.Payload[2+i]); MyPrintf("\n"); +// +// MFI_SendIap2EaPacket(mfi_recv_packet.Payload+2,mfi_recv_packet.PayloadLen-2); + } +} + +void MFI_RecIap2ControlPacket(void) +{ + IAP2_ControlMessageDef message; + message.StartMsb = mfi_recv_packet.Payload[0]; + message.StartLsb = mfi_recv_packet.Payload[1]; + message.IdMsb = mfi_recv_packet.Payload[4]; + message.IdLsb = mfi_recv_packet.Payload[5]; + message.DataLen = mfi_recv_packet.PayloadLen-6; + message.Data = mfi_recv_packet.Payload+6; + if((mfi_recv_packet.Payload[2] <<8) + mfi_recv_packet.Payload[3] == mfi_recv_packet.PayloadLen + && message.StartMsb == MFI_IAP2_CONTROL_SESSION_MESSAGE_START_MSB + && message.StartLsb == MFI_IAP2_CONTROL_SESSION_MESSAGE_START_LSB) + switch(message.IdMsb) + { + case MFI_IAP2_ACCESSORY_AUTHENTICATION_MSB: + MFI_RecIap2ControlAuth(&message); + break; + case MFI_IAP2_ACCESSORY_IDENTIFICATION_MSB: + MFI_RecIap2Identification(&message); + break; + case MFI_IAP2_EA_PROTOCOL_MSB: + MFI_RecIap2EaProtocol(&message); + break; + } +} + +void MFI_RecPayloadError() +{ + mfi_error=1; +} + +void MFI_RecHeaderError() +{ + mfi_error=2; +} + +void MFI_RecLinkPacket(unsigned char* data,unsigned int len) +{ + unsigned int i; + if(MFI_IAP2_LINK_PACKET_START_MSB == data[MFI_IAP2_PACKET_STRUCTURE_START_MSB_OFFSET] + && MFI_IAP2_LINK_PACKET_START_LSB == data[MFI_IAP2_PACKET_STRUCTURE_START_LSB_OFFSET] + && len >= 9 && len != 10 && data[MFI_IAP2_PACKET_STRUCTURE_HEADER_SUM_OFFSET] == MFI_CheckSum(data,8) + && (data[MFI_IAP2_PACKET_STRUCTURE_SEQ_OFFSET] == mfi_recv_packet.Seq || mfi_init ==0 + || data[MFI_IAP2_PACKET_STRUCTURE_SEQ_OFFSET] == ((mfi_recv_packet.Seq +1)&0xff) )) + { + if(mfi_init ==0 ) + mfi_init =1; + mfi_recv_packet.PayloadLen = (len>10)? len-10:0; + mfi_recv_packet.Payload = data+MFI_IAP2_PACKET_STRUCTURE_PAYLOAD_DATA_OFFSET; + mfi_recv_packet.PayloadCheckSum = data[len-1]; + + if(mfi_recv_packet.PayloadLen != 0 ) + { + if(MFI_CheckSum(mfi_recv_packet.Payload,mfi_recv_packet.PayloadLen) == mfi_recv_packet.PayloadCheckSum) + { + mfi_recv_packet.LenMsb = data[MFI_IAP2_PACKET_STRUCTURE_LEN_MSB_OFFSET]; + mfi_recv_packet.LenLsb = data[MFI_IAP2_PACKET_STRUCTURE_LEN_LSB_OFFSET]; + mfi_recv_packet.Control = data[MFI_IAP2_PACKET_STRUCTURE_CONTROL_OFFSET]; + mfi_recv_packet.Seq = data[MFI_IAP2_PACKET_STRUCTURE_SEQ_OFFSET]; + mfi_recv_packet.Ack = data[MFI_IAP2_PACKET_STRUCTURE_ACK_OFFSET]; + mfi_recv_packet.SessionId = data[MFI_IAP2_PACKET_STRUCTURE_SESSION_ID_OFFSET]; + mfi_recv_packet.HeaderCheckSum = data[MFI_IAP2_PACKET_STRUCTURE_HEADER_SUM_OFFSET]; + + if(mfi_recv_packet.Control == MFI_IAP2_CONTROL_RST) + ; + else if(mfi_recv_packet.Control == MFI_IAP2_CONTR0L_SLP) + ; + else if((mfi_recv_packet.Control & (1< MFI_RX_BUF_LENTH) + return 1; + + if(mfi_rx_buf.Len == 0) + { + if(MFI_IAP2_LINK_PACKET_START_MSB == data[MFI_IAP2_PACKET_STRUCTURE_START_MSB_OFFSET] + && MFI_IAP2_LINK_PACKET_START_LSB == data[MFI_IAP2_PACKET_STRUCTURE_START_LSB_OFFSET]) + { + packetLen = (data[MFI_IAP2_PACKET_STRUCTURE_LEN_MSB_OFFSET]<<8) + data[MFI_IAP2_PACKET_STRUCTURE_LEN_LSB_OFFSET]; + if(len >= packetLen ) + { + MFI_RecLinkPacket(data,packetLen); + len -= packetLen; + for(i=0;i= packetLen ) + { + MFI_RecLinkPacket(mfi_rx_buf.Buf,packetLen); + mfi_rx_buf.Len -= packetLen; + for(i=0;i= MFICP_LEN_CERTIFICATE_DATA_LENGTH_MIN + && (len[0]<<8) + len[1] <= MFICP_LEN_CERTIFICATE_DATA_LENGTH_MAX) + { + MyPrintf("len [0] = %x len [1] = %x \r\n",len[0],len[1]); + return (len[0]<<8) + len[1] ; + } + else + return 0; + } + else + return 0; +} + +char MFICP_ReadCertificateData(unsigned char *dataptr,int len) +{ + int i=0; + MFICP_ReadReg(MFICP_ADDR_CERTIFICATE_DATA1,dataptr,MFICP_LEN_CERTIFICATE_DATA); + i += MFICP_LEN_CERTIFICATE_DATA; + MFICP_ReadReg(MFICP_ADDR_CERTIFICATE_DATA2,dataptr+i,MFICP_LEN_CERTIFICATE_DATA); + i += MFICP_LEN_CERTIFICATE_DATA; + MFICP_ReadReg(MFICP_ADDR_CERTIFICATE_DATA3,dataptr+i,MFICP_LEN_CERTIFICATE_DATA); + i += MFICP_LEN_CERTIFICATE_DATA; + MFICP_ReadReg(MFICP_ADDR_CERTIFICATE_DATA4,dataptr+i,MFICP_LEN_CERTIFICATE_DATA); + i += MFICP_LEN_CERTIFICATE_DATA; + MFICP_ReadReg(MFICP_ADDR_CERTIFICATE_DATA5,dataptr+i,len-i); + + MyPrintf("CertificateData %x:\n",len); + for(i =0; i >8; + data[1] = len; + return MFICP_WriteReg(MFICP_ADDR_CHALLENGE_DATA_LENGTH,data,MFICP_LEN_CHALLENGE_DATA_LENGTH); +} + +char MFICP_WriteChallengeData(unsigned char *dataptr) +{ + return MFICP_WriteReg(MFICP_ADDR_CHALLENGE_DATA,dataptr,MFICP_LEN_CHALLENGE_DATA); +} + +char MFICP_WriteStatusProcControl(void) +{ + unsigned char data = 1; + return MFICP_WriteReg(MFICP_ADDR_AUTH_CONTROL_AND_STATUS,&data,MFICP_LEN_AUTH_CONTROL_AND_STATUS); +} + +char MFICP_ReadAuthStatus(unsigned char *data) +{ + return MFICP_ReadReg(MFICP_ADDR_AUTH_CONTROL_AND_STATUS,data,MFICP_LEN_AUTH_CONTROL_AND_STATUS); +} + +int MFICP_ReadChellengeResDataLen(void) +{ + unsigned char len[MFICP_LEN_CHALLENGE_RES_DATA_LENGTH]={0}; + if(MFICP_ReadReg(MFICP_ADDR_CHALLENGE_RES_DATA_LENGTH,len,MFICP_LEN_CHALLENGE_RES_DATA_LENGTH)) + return (len[0]<<8) + len[1] ; + else + return 0; +} + +char MFICP_ReadChellengeResData(unsigned char *dataptr) +{ + return MFICP_ReadReg(MFICP_ADDR_CHALLENGE_RES_DATA,dataptr,MFICP_LEN_CHALLENGE_RES_DATA); +} Index: BT_doublebyte/sdk/ModuleDemo/BlueTooth/BT_BLE2/user/main.c =================================================================== --- /YC3121_demo/ModuleDemo/BlueTooth/BT_doublebyte/sdk/ModuleDemo/BlueTooth/BT_BLE2/user/main.c (revision 929) +++ /YC3121_demo/ModuleDemo/BlueTooth/BT_doublebyte/sdk/ModuleDemo/BlueTooth/BT_BLE2/user/main.c (working copy) @@ -30,6 +30,7 @@ #include "yc_qspi.h" #include "yc_ipc2.h" #include "board_config.h" +#include "mfi_coprocessor.h" /* Private typedef -----------------------------------------------------------*/ /* Private define ------------------------------------------------------------*/ @@ -232,6 +233,7 @@ #endif MyPrintf("bt init ok\n"); + MFICP_Test(); while (1) { #ifdef UART_TO_IPC @@ -252,6 +254,7 @@ } #else rlen = prt_get_bt_data(); + MFI_SmProcess(); #endif } }