/* wcn_compressor_init - create a compressor and do init * @ name - compressor's name * @ L1_buf_sz - L1 buffer size * @ L2_buf_sz - L2 buffer size * * Retunr object's pointer if success, else NULL */ P_WCN_COMPRESSOR_T wcn_compressor_init(PUINT8 name, INT32 L1_buf_sz, INT32 L2_buf_sz) { z_stream *pstream = NULL; P_WCN_COMPRESSOR_T compress = NULL; compress = (P_WCN_COMPRESSOR_T)osal_malloc(sizeof(WCN_COMPRESSOR_T)); if (!compress) { STP_DBG_ERR_FUNC("alloc compressor failed!\n"); goto fail; } osal_memset(compress, 0, sizeof(WCN_COMPRESSOR_T)); osal_memcpy(compress->name, name, STP_OJB_NAME_SZ); compress->f_compress_en = 0; compress->compress_type = GZIP; if (compress->compress_type == GZIP) { compress->worker = osal_malloc(sizeof(z_stream)); if (!compress->worker) { STP_DBG_ERR_FUNC("alloc stream failed!\n"); goto fail; } pstream = (z_stream*)compress->worker; pstream->workspace = osal_malloc(zlib_deflate_workspacesize(MAX_WBITS, MAX_MEM_LEVEL)); if (!pstream->workspace) { STP_DBG_ERR_FUNC("alloc workspace failed!\n"); goto fail; } zlib_deflateInit2(pstream, Z_DEFAULT_COMPRESSION, Z_DEFLATED, -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY); } compress->handler = wcn_gzip_compressor; compress->L1_buf_sz = L1_buf_sz; compress->L2_buf_sz = L2_buf_sz; compress->L1_pos = 0; compress->L2_pos = 0; compress->uncomp_size = 0; compress->crc32 = 0xffffffffUL; compress->L1_buf = osal_malloc(compress->L1_buf_sz); if (!compress->L1_buf) { STP_DBG_ERR_FUNC("alloc %d bytes for L1 buf failed!\n", compress->L1_buf_sz); goto fail; } compress->L2_buf = osal_malloc(compress->L2_buf_sz); if (!compress->L2_buf) { STP_DBG_ERR_FUNC("alloc %d bytes for L2 buf failed!\n", compress->L2_buf_sz); goto fail; } STP_DBG_INFO_FUNC("create compressor OK! L1 %d bytes, L2 %d bytes\n", L1_buf_sz, L2_buf_sz); return compress; fail: if (compress) { if (compress->L2_buf) { osal_free(compress->L2_buf); compress->L2_buf = NULL; } if (compress->L1_buf) { osal_free(compress->L1_buf); compress->L1_buf = NULL; } if (compress->worker) { pstream = (z_stream*)compress->worker; if ((compress->compress_type == GZIP) && pstream->workspace) { zlib_deflateEnd(pstream); osal_free(pstream->workspace); } osal_free(compress->worker); compress->worker = NULL; } if (compress->worker) { osal_free(compress->worker); compress->worker = NULL; } osal_free(compress); compress = NULL; } STP_DBG_ERR_FUNC("init failed!\n"); return NULL; }
/********************************************************************* * @fn SimpleProfile_GetParameter * * @brief Get a Simple Profile parameter. * * @param param - Profile parameter ID * @param value - pointer to data to put. This is dependent on * the parameter ID and WILL be cast to the appropriate * data type (example: data type of uint16 will be cast to * uint16 pointer). * * @return bStatus_t */ bStatus_t SimpleProfile_GetParameter( uint8 param, void *value, uint8 *returnBytes) { bStatus_t ret = SUCCESS; switch ( param ) { case SIMPLEPROFILE_CHAR1: *((uint8*)value) = simpleProfileChar1; *returnBytes = 1; break; case SIMPLEPROFILE_CHAR2: *((uint8*)value) = simpleProfileChar2; *returnBytes = 1; break; case SIMPLEPROFILE_CHAR3: *((uint8*)value) = simpleProfileChar3; *returnBytes = 1; break; case SIMPLEPROFILE_CHAR4: *((uint8*)value) = simpleProfileChar4; *returnBytes = 1; break; case SIMPLEPROFILE_CHAR5: VOID osal_memcpy( value, simpleProfileChar5, simpleProfileChar5Len ); *returnBytes = simpleProfileChar5Len; break; case SIMPLEPROFILE_CHAR6: VOID osal_memcpy( value, simpleProfileChar6, simpleProfileChar6Len ); *returnBytes = simpleProfileChar6Len; break; case SIMPLEPROFILE_CHAR7: VOID osal_memcpy( value, simpleProfileChar7, simpleProfileChar7Len ); *returnBytes = simpleProfileChar7Len; break; case SIMPLEPROFILE_CHAR8: VOID osal_memcpy( value, simpleProfileChar8, simpleProfileChar8Len ); *returnBytes = simpleProfileChar8Len; break; case SIMPLEPROFILE_CHAR9: VOID osal_memcpy( value, simpleProfileChar9, simpleProfileChar9Len ); *returnBytes = simpleProfileChar9Len; break; case SIMPLEPROFILE_CHARA: VOID osal_memcpy( value, simpleProfileCharA, simpleProfileCharALen ); *returnBytes = simpleProfileCharALen; break; default: ret = INVALIDPARAMETER; *returnBytes = 0; break; } return ( ret ); }
/********************************************************************* * @fn simpleProfile_WriteAttrCB * * @brief Validate attribute data prior to a write operation * * @param connHandle - connection message was received on * @param pAttr - pointer to attribute * @param pValue - pointer to data to be written * @param len - length of data * @param offset - offset of the first octet to be written * * @return Success or Failure */ static bStatus_t simpleProfile_WriteAttrCB( uint16 connHandle, gattAttribute_t *pAttr, uint8 *pValue, uint8 len, uint16 offset ) { bStatus_t status = SUCCESS; uint8 notifyApp = 0xFF; // If attribute permissions require authorization to write, return error if ( gattPermitAuthorWrite( pAttr->permissions ) ) { // Insufficient authorization return ( ATT_ERR_INSUFFICIENT_AUTHOR ); } if ( pAttr->type.len == ATT_BT_UUID_SIZE ) { // 16-bit UUID uint16 uuid = BUILD_UINT16( pAttr->type.uuid[0], pAttr->type.uuid[1]); switch ( uuid ) { case SIMPLEPROFILE_CHAR1_UUID: case SIMPLEPROFILE_CHAR3_UUID: //Validate the value // Make sure it's not a blob oper if ( offset == 0 ) { if ( len != 1 ) { status = ATT_ERR_INVALID_VALUE_SIZE; } } else { status = ATT_ERR_ATTR_NOT_LONG; } //Write the value if ( status == SUCCESS ) { uint8 *pCurValue = (uint8 *)pAttr->pValue; *pCurValue = pValue[0]; if( pAttr->pValue == &simpleProfileChar1 ) { notifyApp = SIMPLEPROFILE_CHAR1; } else { notifyApp = SIMPLEPROFILE_CHAR3; } } break; case SIMPLEPROFILE_CHAR5_UUID: if ( offset == 0 ) { //if ( len != SIMPLEPROFILE_CHAR6_LEN ) if ( len > SIMPLEPROFILE_CHAR5_LEN ) { status = ATT_ERR_INVALID_VALUE_SIZE; } } else { status = ATT_ERR_ATTR_NOT_LONG; } //Write the value if ( status == SUCCESS ) { VOID osal_memcpy( pAttr->pValue, pValue, len ); simpleProfileChar5Len = len; notifyApp = SIMPLEPROFILE_CHAR5; } break; case SIMPLEPROFILE_CHAR6_UUID: //Validate the value // Make sure it's not a blob oper //LCD_WRITE_STRING_VALUE( "WriteAttrCB 6 len=", len, 10, HAL_LCD_LINE_1 ); //LCD_WRITE_STRING_VALUE( "WriteAttrCB 6 len2=", simpleProfileChar6Len, 10, HAL_LCD_LINE_1 ); if ( offset == 0 ) { //if ( len != SIMPLEPROFILE_CHAR6_LEN ) if ( len > SIMPLEPROFILE_CHAR6_LEN ) { status = ATT_ERR_INVALID_VALUE_SIZE; } } else { status = ATT_ERR_ATTR_NOT_LONG; } //Write the value if ( status == SUCCESS ) { //VOID osal_memcpy( pAttr->pValue, pValue, SIMPLEPROFILE_CHAR6_LEN ); VOID osal_memcpy( pAttr->pValue, pValue, len ); simpleProfileChar6Len = len; notifyApp = SIMPLEPROFILE_CHAR6; } break; case SIMPLEPROFILE_CHAR7_UUID: if ( offset == 0 ) { if ( len > SIMPLEPROFILE_CHAR7_LEN ) { status = ATT_ERR_INVALID_VALUE_SIZE; } } else { status = ATT_ERR_ATTR_NOT_LONG; } //Write the value if ( status == SUCCESS ) { VOID osal_memcpy( pAttr->pValue, pValue, len ); simpleProfileChar7Len = len; notifyApp = SIMPLEPROFILE_CHAR7; } break; case SIMPLEPROFILE_CHAR8_UUID: if ( offset == 0 ) { if ( len > SIMPLEPROFILE_CHAR8_LEN ) { status = ATT_ERR_INVALID_VALUE_SIZE; } } else { status = ATT_ERR_ATTR_NOT_LONG; } //Write the value if ( status == SUCCESS ) { VOID osal_memcpy( pAttr->pValue, pValue, len ); simpleProfileChar8Len = len; notifyApp = SIMPLEPROFILE_CHAR8; } break; case SIMPLEPROFILE_CHAR9_UUID: if ( offset == 0 ) { if ( len > SIMPLEPROFILE_CHAR9_LEN ) { status = ATT_ERR_INVALID_VALUE_SIZE; } } else { status = ATT_ERR_ATTR_NOT_LONG; } //Write the value if ( status == SUCCESS ) { VOID osal_memcpy( pAttr->pValue, pValue, len ); simpleProfileChar9Len = len; notifyApp = SIMPLEPROFILE_CHAR9; } break; case SIMPLEPROFILE_CHARA_UUID: if ( offset == 0 ) { if ( len > SIMPLEPROFILE_CHARA_LEN ) { status = ATT_ERR_INVALID_VALUE_SIZE; } } else { status = ATT_ERR_ATTR_NOT_LONG; } //Write the value if ( status == SUCCESS ) { VOID osal_memcpy( pAttr->pValue, pValue, len ); simpleProfileCharALen = len; notifyApp = SIMPLEPROFILE_CHARA; } break; case GATT_CLIENT_CHAR_CFG_UUID: status = GATTServApp_ProcessCCCWriteReq( connHandle, pAttr, pValue, len, offset, GATT_CLIENT_CFG_NOTIFY ); break; default: // Should never get here! (characteristics 2 and 4 do not have write permissions) status = ATT_ERR_ATTR_NOT_FOUND; break; } } else { // 128-bit UUID status = ATT_ERR_INVALID_HANDLE; } // If a charactersitic value changed then callback function to notify application of change if ( (notifyApp != 0xFF ) && simpleProfile_AppCBs && simpleProfile_AppCBs->pfnSimpleProfileChange ) { simpleProfile_AppCBs->pfnSimpleProfileChange( notifyApp ); } return ( status ); }
/************************************************************************************************** * @fn pulseTestingDataRx * * @brief This function is called by pulseAfMsgRx() to process incoming data This is not used in * normal operation. This is used for testing system with differnt payload sizes. * input parameters * * @param msg - A pointer to the afIncomingMSGPacket_t packet. * * output parameters * * None. * * @return None. ************************************************************************************************** */ static void pulseTestingDataRx(afIncomingMSGPacket_t *msg) { uint8 fcs = 0, idx; int8 Rssi; //Convert LQI to RSSI Rssi =(int8)(((msg->LinkQuality * 97)/0xFF) -87); //uint8 *TestRxBuffer; //TestRxBuffer = (uint8*)osal_mem_alloc(MHMS_TEST_BUFF_LEN); // Last announce broadcast to stop must have expired before a parent could forward to a ZED. if (INVALID_NODE_ADDR == pulseAddr) { (void)osal_set_event(pulseTaskId, PULSE_EVT_ANN); } TestRxBuffer[PULSE_SOP_IDX] = PULSE_SOP_VAL; TestRxBuffer[PULSE_ADR_LSB] = LO_UINT16(msg->srcAddr.addr.shortAddr); TestRxBuffer[PULSE_ADR_MSB] = HI_UINT16(msg->srcAddr.addr.shortAddr); // 1st byte of message is skipped - CMD is always 0 for data. (void)osal_memcpy(TestRxBuffer+PULSE_DAT_OFF, msg->cmd.Data+1, MHMS_TEST_PAYLOAD_LEN-1); //MHMS copies one buffer to another for (idx = PULSE_ADR_LSB; idx < MHMS_FCS_IDX; idx++) { fcs ^= TestRxBuffer[idx]; } TestRxBuffer[idx] = fcs; uint8 PktSeqNum; uint8 parentAddrLSB; uint8 parentAddrMSB; uint8 tsensorBuf[15]; parentAddrLSB= TestRxBuffer[11]; parentAddrMSB= TestRxBuffer[12]; PktSeqNum = TestRxBuffer[13]; //Start of Frame Delimiter tsensorBuf[0]=0xFE; tsensorBuf[1]=10; tsensorBuf[2]=LO_UINT16(0x8746); tsensorBuf[3]=HI_UINT16(0x8746); //Source Address tsensorBuf[4] = LO_UINT16(msg->srcAddr.addr.shortAddr); tsensorBuf[5] = HI_UINT16(msg->srcAddr.addr.shortAddr); tsensorBuf[6]=LO_UINT16(2); //MHMS are 6 - 9 being used for anything? tsensorBuf[7]=HI_UINT16(2); tsensorBuf[8]=LO_UINT16(4); tsensorBuf[9]=HI_UINT16(4); //Temperature and Voltage Data tsensorBuf[10]= Rssi; tsensorBuf[11]= PktSeqNum; //Parent Address tsensorBuf[12]= parentAddrLSB; tsensorBuf[13]= parentAddrMSB; //FCS Check on the middle 13 bytes tsensorBuf[14] = calcFCS(&tsensorBuf[1], 13 ); HalUARTWrite(PULSE_PORT, tsensorBuf, 15); //For communicating with the Zigbee sensor Monitor //osal_mem_free(TestRxBuffer); }
/******************************************************************************************************** * @fn ZMacSecuritySetReq * * @brief Write a MAC Security PIB attribute. * * @param attr - PIB attribute to Set * @param value - pointer to the data * * @return status ********************************************************************************************************/ uint8 ZMacSecuritySetReq( uint8 attr, byte *value ) { uint8 keyIndex, entry; uint32 frameCounter; uint8 *ptr; uint8 tmp[MAX_SECURITY_PIB_SET_ENTRY]; /* This must cover the largest single PIB entry */ uint8 temp[MAX_SECURITY_PIB_SET_ENTRY]; /* This must cover the largest single PIB entry */ /* Note that the Transform byte array to propriety PIB struct below works * because the members of the structures are all defined manually in a way, * where memcpy would work, without usage of explicit 'pack', they fit * such that memcpy would work */ ptr = (uint8 *) value; switch (attr) { case ZMacKeyIdLookupEntry: keyIndex = *ptr++; /* key_index */ entry = *ptr++; /* key_id_lookup_index */ /* Transform byte array to propriety PIB struct */ osal_memcpy(tmp, ptr, sizeof(keyIdLookupDescriptor_t)); osal_memcpy(&((macSecurityPibKeyIdLookupEntry_t *)temp)->macKeyIdLookupEntry, tmp, sizeof(keyIdLookupDescriptor_t)); ((macSecurityPibKeyIdLookupEntry_t *)temp)->key_id_lookup_index = entry; ((macSecurityPibKeyIdLookupEntry_t *)temp)->key_index = keyIndex; return (ZMacStatus_t) MAC_MlmeSetSecurityReq( attr, temp ); break; case ZMacKeyDeviceEntry: keyIndex = *ptr++; /* key_index */ entry = *ptr++; /* key_device_index */ /* Transform byte array to propriety PIB struct */ osal_memcpy(tmp, ptr, sizeof(keyDeviceDescriptor_t)); osal_memcpy(&((macSecurityPibKeyDeviceEntry_t *)temp)->macKeyDeviceEntry, tmp, sizeof(keyDeviceDescriptor_t)); ((macSecurityPibKeyDeviceEntry_t *)temp)->key_device_index = entry; ((macSecurityPibKeyDeviceEntry_t *)temp)->key_index = keyIndex; return (ZMacStatus_t) MAC_MlmeSetSecurityReq( attr, temp ); break; case ZMacKeyUsageEntry: keyIndex = *ptr++; /* key_index */ entry = *ptr++; /* key_key_usage_index */ /* Transform byte array to propriety PIB struct */ osal_memcpy(tmp, ptr, sizeof(keyUsageDescriptor_t)); osal_memcpy(&((macSecurityPibKeyUsageEntry_t *)temp)->macKeyUsageEntry, tmp, sizeof(keyUsageDescriptor_t)); ((macSecurityPibKeyUsageEntry_t *)temp)->key_key_usage_index = entry; ((macSecurityPibKeyUsageEntry_t *)temp)->key_index = keyIndex; return (ZMacStatus_t) MAC_MlmeSetSecurityReq( attr, temp ); break; case ZMacKeyEntry: keyIndex = *ptr++; /* key_index */ /* Transform byte array to propriety PIB struct */ osal_memcpy(tmp, ptr, MAC_KEY_MAX_LEN); osal_memcpy(&((macSecurityPibKeyEntry_t *)temp)->keyEntry, tmp, MAC_KEY_MAX_LEN); ptr+=MAC_KEY_MAX_LEN; osal_memcpy(&frameCounter, ptr, sizeof(frameCounter)); ((macSecurityPibKeyEntry_t *)temp)->frameCounter = frameCounter; ((macSecurityPibKeyEntry_t *)temp)->key_index = keyIndex; return (ZMacStatus_t) MAC_MlmeSetSecurityReq( attr, temp ); break; case ZMacDeviceEntry: entry = *ptr++; /* Transform byte array to propriety PIB struct */ osal_memcpy(tmp, ptr, sizeof(deviceDescriptor_t)); osal_memcpy(&((macSecurityPibDeviceEntry_t *)temp)->macDeviceEntry, tmp, sizeof(deviceDescriptor_t)); ((macSecurityPibDeviceEntry_t *)temp)->device_index = entry; return (ZMacStatus_t) MAC_MlmeSetSecurityReq( attr, temp ); break; case ZMacSecurityLevelEntry: entry = *ptr++; /* security_level_index */ /* Transform byte array to propriety PIB struct */ osal_memcpy(tmp, ptr, sizeof(securityLevelDescriptor_t)); osal_memcpy(&((macSecurityPibSecurityLevelEntry_t *)temp)->macSecurityLevelEntry, tmp, sizeof(securityLevelDescriptor_t)); ((macSecurityPibSecurityLevelEntry_t *)temp)->security_level_index = entry; return (ZMacStatus_t) MAC_MlmeSetSecurityReq( attr, temp ); break; } return (ZMacStatus_t) MAC_MlmeSetSecurityReq( attr, value ); }
/********************************************************************* * @brief Get a GAP Role parameter. * * Public function defined in broadcaster.h. */ bStatus_t GAPRole_GetParameter( uint16 param, void *pValue ) { bStatus_t ret = SUCCESS; switch ( param ) { case GAPROLE_PROFILEROLE: *((uint8*)pValue) = gapRole_profileRole; break; case GAPROLE_BD_ADDR: VOID osal_memcpy( pValue, gapRole_bdAddr, B_ADDR_LEN ) ; break; case GAPROLE_ADVERT_ENABLED: *((uint8*)pValue) = gapRole_AdvEnabled; break; case GAPROLE_ADVERT_OFF_TIME: *((uint16*)pValue) = gapRole_AdvertOffTime; break; case GAPROLE_ADVERT_DATA: VOID osal_memcpy( pValue , gapRole_AdvertData, gapRole_AdvertDataLen ); break; case GAPROLE_SCAN_RSP_DATA: VOID osal_memcpy( pValue, gapRole_ScanRspData, gapRole_ScanRspDataLen ) ; break; case GAPROLE_ADV_EVENT_TYPE: *((uint8*)pValue) = gapRole_AdvEventType; break; case GAPROLE_ADV_DIRECT_TYPE: *((uint8*)pValue) = gapRole_AdvDirectType; break; case GAPROLE_ADV_DIRECT_ADDR: VOID osal_memcpy( pValue, gapRole_AdvDirectAddr, B_ADDR_LEN ) ; break; case GAPROLE_ADV_CHANNEL_MAP: *((uint8*)pValue) = gapRole_AdvChanMap; break; case GAPROLE_ADV_FILTER_POLICY: *((uint8*)pValue) = gapRole_AdvFilterPolicy; break; default: // The param value isn't part of this profile, try the GAP. if ( param < TGAP_PARAMID_MAX ) { *((uint16*)pValue) = GAP_GetParamValue( param ); } else { ret = INVALIDPARAMETER; } break; } return ( ret ); }
/********************************************************************* * @fn oadManagerEventCB * * @brief Central event callback function. * * @param pEvent - pointer to event structure * * @return none */ static void oadManagerEventCB( gapCentralRoleEvent_t *pEvent ) { switch ( pEvent->gap.opcode ) { case GAP_DEVICE_INIT_DONE_EVENT: { VOID osal_memcpy( oadManagerAddr, pEvent->initDone.devAddr, B_ADDR_LEN ); #if (defined HAL_LCD) && (HAL_LCD == TRUE) LCD_WRITE_STRING( "OAD Manager", HAL_LCD_LINE_1 ); LCD_WRITE_STRING( bdAddr2Str( oadManagerAddr ), HAL_LCD_LINE_2 ); #endif } break; case GAP_DEVICE_INFO_EVENT: { // if filtering device discovery results based on service UUID if ( DEFAULT_DEV_DISC_BY_SVC_UUID == TRUE ) { if ( oadManagerFindServUUID( pEvent->deviceInfo.pEvtData, pEvent->deviceInfo.dataLen ) ) { oadManagerAddDeviceInfo( pEvent->deviceInfo.addr, pEvent->deviceInfo.addrType ); } } } break; case GAP_DEVICE_DISCOVERY_EVENT: { // discovery complete oadManagerScanning = FALSE; // if not filtering device discovery results based on service UUID if ( DEFAULT_DEV_DISC_BY_SVC_UUID == FALSE ) { // Copy results oadManagerScanRes = pEvent->discCmpl.numDevs; osal_memcpy( oadManagerDevList, pEvent->discCmpl.pDevList, (sizeof( gapDevRec_t ) * pEvent->discCmpl.numDevs) ); } #if (defined HAL_LCD) && (HAL_LCD == TRUE) LCD_WRITE_STRING_VALUE( "Devices Found", oadManagerScanRes, 10, HAL_LCD_LINE_1 ); if ( oadManagerScanRes > 0 ) { LCD_WRITE_STRING( "<- To Select", HAL_LCD_LINE_2 ); } #endif // initialize scan index to last device oadManagerScanIdx = oadManagerScanRes; } break; case GAP_LINK_ESTABLISHED_EVENT: { if ( pEvent->gap.hdr.status == SUCCESS ) { oadManagerState = BLE_STATE_CONNECTED; oadManagerConnHandle = pEvent->linkCmpl.connectionHandle; (void)osal_set_event(oadManagerTaskId, CONN_INTERVAL_EVT); #if (defined HAL_LCD) && (HAL_LCD == TRUE) LCD_WRITE_STRING( "Connected", HAL_LCD_LINE_1 ); LCD_WRITE_STRING( "", HAL_LCD_LINE_3 ); #endif } else { oadManagerState = BLE_STATE_IDLE; oadManagerConnHandle = GAP_CONNHANDLE_INIT; } } break; case GAP_LINK_TERMINATED_EVENT: { oadManagerState = BLE_STATE_IDLE; oadManagerConnHandle = GAP_CONNHANDLE_INIT; #if (defined HAL_LCD) && (HAL_LCD == TRUE) LCD_WRITE_STRING( "OAD Manager", HAL_LCD_LINE_1 ); LCD_WRITE_STRING( bdAddr2Str( oadManagerAddr ), HAL_LCD_LINE_2 ); LCD_WRITE_STRING( "Disconnected", HAL_LCD_LINE_3 ); #endif } break; default: break; } }
/*================================================================================================= * @fn rxAddrIsr * * @brief Receive ISR state for decoding address. Reads and stores the address information * from the incoming packet. * * @param none * * @return none *================================================================================================= */ static void rxAddrIsr(void) { uint8 buf[MAX_ADDR_FIELDS_LEN]; uint8 dstAddrMode; uint8 srcAddrMode; #ifdef FEATURE_MAC_SECURITY uint8 securityControl; #endif /* MAC_SECURITY */ uint8 * p; MAC_ASSERT(rxNextLen != 0); /* logic assumes at least one address byte in buffer */ /* read out address fields into local buffer in one shot */ MAC_RADIO_READ_RX_FIFO(buf, rxNextLen); /* set pointer to buffer with addressing fields */ p = buf; /* destination address */ dstAddrMode = MAC_DEST_ADDR_MODE(&rxBuf[1]); if (dstAddrMode != SADDR_MODE_NONE) { pRxBuf->mac.srcPanId = pRxBuf->mac.dstPanId = BUILD_UINT16(p[0], p[1]); p += MAC_PAN_ID_FIELD_LEN; if (dstAddrMode == SADDR_MODE_EXT) { sAddrExtCpy(pRxBuf->mac.dstAddr.addr.extAddr, p); p += MAC_EXT_ADDR_FIELD_LEN; } else { pRxBuf->mac.dstAddr.addr.shortAddr = BUILD_UINT16(p[0], p[1]); p += MAC_SHORT_ADDR_FIELD_LEN; } } /* sources address */ srcAddrMode = MAC_SRC_ADDR_MODE(&rxBuf[1]); if (srcAddrMode != SADDR_MODE_NONE) { if (!(pRxBuf->internal.flags & MAC_RX_FLAG_INTRA_PAN)) { pRxBuf->mac.srcPanId = BUILD_UINT16(p[0], p[1]); p += MAC_PAN_ID_FIELD_LEN; } if (srcAddrMode == SADDR_MODE_EXT) { sAddrExtCpy(pRxBuf->mac.srcAddr.addr.extAddr, p); } else { pRxBuf->mac.srcAddr.addr.shortAddr = BUILD_UINT16(p[0], p[1]); } } #ifdef FEATURE_MAC_SECURITY if (MAC_SEC_ENABLED(&rxBuf[1])) { uint8 keyIdMode; if (MAC_FRAME_VERSION(&rxBuf[1]) == 0) { /* MAC_UNSUPPORTED_LEGACY - Cancel the outgoing TX ACK. * It may be too late but we have to try. */ MAC_RADIO_CANCEL_TX_ACK(); /* clean up after unsupported security legacy */ macRxHaltCleanup(); return; } /* Copy addressing fields to RX buffer */ osal_memcpy(pRxBuf->mhr.p, buf, rxNextLen); pRxBuf->mhr.p += rxNextLen; pRxBuf->mhr.len += rxNextLen; /*------------------------------------------------------------------------------- * Prepare for auxiliary security header interrupts. */ /* read out security control field from FIFO (threshold set so bytes are guaranteed to be there) */ MAC_RADIO_READ_RX_FIFO(&securityControl, MAC_SEC_CONTROL_FIELD_LEN); /* Copy security fields to MHR buffer */ *pRxBuf->mhr.p = securityControl; pRxBuf->mhr.p += MAC_SEC_CONTROL_FIELD_LEN; pRxBuf->mhr.len += MAC_SEC_CONTROL_FIELD_LEN; /* store security level and key ID mode */ pRxBuf->sec.securityLevel = SECURITY_LEVEL(securityControl); pRxBuf->sec.keyIdMode = keyIdMode = KEY_IDENTIFIER_MODE(securityControl); /* Corrupted RX frame, should never occur. */ if ((keyIdMode > MAC_KEY_ID_MODE_8) /* Get the next RX length according to AuxLen table minus security control field. * The security control length is counted already. */ || ((macKeySourceLen[keyIdMode] + MAC_FRAME_COUNTER_LEN) >= rxPayloadLen) /* Security Enabled subfield is one, but the Security Level in the header is zero: * MAC_UNSUPPORTED_SECURITY - Cancel the outgoing TX ACK. */ || (pRxBuf->sec.securityLevel == MAC_SEC_LEVEL_NONE)) { /* It may be too late but we have to try. */ MAC_RADIO_CANCEL_TX_ACK(); /* clean up after unsupported security or corrupted RX frame. */ macRxHaltCleanup(); return; } /* get the next RX length according to AuxLen table minus security control field. * The sceurity control length is counted already. */ rxNextLen = macKeySourceLen[keyIdMode] + MAC_FRAME_COUNTER_LEN; MAC_RADIO_SET_RX_THRESHOLD(rxNextLen); pFuncRxState = &rxSecurityHdrIsr; } else #endif /* MAC_SECURITY */ { /* clear security level */ pRxBuf->sec.securityLevel = MAC_SEC_LEVEL_NONE; /*------------------------------------------------------------------------------- * Prepare for payload interrupts. */ pFuncRxState = &rxPayloadIsr; rxPrepPayload(); } }
/*************************************************************************************************** * @fn Uart_Msg_Parse * * @brief parse uart Msg,this msg was came from e009 uart * * @param pBuffer: msg; length: msg length * * @return None ***************************************************************************************************/ bool Uart_Msg_Parse(uint8* pBuffer, uint8 length) { bool ret = TRUE; // pBuffer[0] = MSG_IDENTIFICATION;pBuffer[1]=msd id switch(pBuffer[1]) { case ID_E0092BLE_G_RSP: last_uart_send.msg_buffer[0] = 0; break; case ID_E0092BLE_TIME: BLE_Common_Response(ID_E0092BLE_TIME,RSP_OK); uart_pulse_timeout_count = 0; Set_Ble_Time(pBuffer+3); break; case ID_E0092BLE_REBOOT_BLE: BLE_Common_Response(ID_E0092BLE_REBOOT_BLE,RSP_OK); BLE_Reboot(); break; case ID_E0092BLE_IMEI: BLE_Common_Response(ID_E0092BLE_IMEI,RSP_OK); //gE009_ready = true; //osal_start_timerEx( simpleBLETaskId, SBP_E009_READY, 250 ); osal_memcpy(gSerial_Num[DEV_A].imei,pBuffer+3,SERIAl_NUM_LEN); break; case ID_E0092BLE_IMSI: BLE_Common_Response(ID_E0092BLE_IMSI,RSP_OK); gE009_ready = true; osal_start_timerEx( simpleBLETaskId, SBP_E009_READY, 250 ); osal_memcpy(gSerial_Num[DEV_A].imsi,pBuffer+3,SERIAl_NUM_LEN); break; case ID_E0092BLE_BAT: //QST E009 to BLE BLE_Common_Response(ID_E0092BLE_BAT,RSP_OK); //sys_config.battery = *(pBuffer+3); break; case ID_E0092BLE_START_E009: BLE_Common_Response(ID_E0092BLE_START_E009,RSP_OK); BLE_Powerup_QST_E009(true); break; case ID_E0092BLE_POWEROFF: //QST E009 to BLE,power off himself BLE_Common_Response(ID_E0092BLE_POWEROFF,RSP_OK); BLE_Powerup_QST_E009(false); break; case ID_E0092BLE_REBOOT_OTHER: //HWJ reboot QST, QST reboot HWJ BLE_Common_Response(ID_E0092BLE_REBOOT_OTHER,RSP_OK); BLE_Reboot_Other(); break; case ID_E0092BLE_STATE: E009_state = *(pBuffer+3); if(E009_state == E009_STATE_SLEEP) { Save_E009_powerup_time( pBuffer+4 ); } BLE_Common_Response(ID_E0092BLE_STATE,E009_state); break; case ID_E0092BLE_START_ADV: //QST E009 to BLE, start advertising BLE_Common_Response(ID_E0092BLE_START_ADV,RSP_OK); BLE_start_adv(); break; case ID_E0092BLE_PAR: BLE_Common_Response(ID_E0092BLE_PAR,RSP_OK); BLE_set_par( pBuffer+3 ); break; case ID_E0092BLE_REBOOT: BLE_Common_Response(ID_E0092BLE_REBOOT,RSP_OK); BLE_Reboot_E009(); break; default: ret = FALSE; break; } return ret; }
/********************************************************************* * @fn SampleApp_Init * * @brief Initialization function for the Generic App Task. * This is called during initialization and should contain * any application specific initialization (ie. hardware * initialization/setup, table initialization, power up * notificaiton ... ). * * @param task_id - the ID assigned by OSAL. This ID should be * used to send messages and set timers. * * @return none */ void SampleApp_Init( uint8 task_id ) { macRadioSetTxPower(20); SampleApp_TaskID = task_id; SampleApp_NwkState = DEV_INIT; SampleApp_TransID = 0; /***********串口初始化****************/ MT_UartInit(); //串口配置初始化 MT_UartRegisterTaskID(task_id);//登记串口任务号 HalUARTWrite(0,"Hello World\r\n",13); // (串口 0,'字符',字符个数) // Device hardware initialization can be added here or in main() (Zmain.c). // If the hardware is application specific - add it here. // If the hardware is other parts of the device add it in main(). #if defined ( BUILD_ALL_DEVICES ) // The "Demo" target is setup to have BUILD_ALL_DEVICES and HOLD_AUTO_START // We are looking at a jumper (defined in SampleAppHw.c) to be jumpered // together - if they are - we will start up a coordinator. Otherwise, // the device will start as a router. if ( readCoordinatorJumper() ) zgDeviceLogicalType = ZG_DEVICETYPE_COORDINATOR; else zgDeviceLogicalType = ZG_DEVICETYPE_ROUTER; #endif // BUILD_ALL_DEVICES #if defined ( HOLD_AUTO_START ) // HOLD_AUTO_START is a compile option that will surpress ZDApp // from starting the device and wait for the application to // start the device. ZDOInitDevice(0); #endif // Setup for the periodic message's destination address // Broadcast to everyone SampleApp_Periodic_DstAddr.addrMode = (afAddrMode_t)AddrBroadcast; SampleApp_Periodic_DstAddr.endPoint = SAMPLEAPP_ENDPOINT; SampleApp_Periodic_DstAddr.addr.shortAddr = 0xFFFF; // Setup for the flash command's destination address - Group 1 SampleApp_Flash_DstAddr.addrMode = (afAddrMode_t)afAddrGroup; SampleApp_Flash_DstAddr.endPoint = SAMPLEAPP_ENDPOINT; SampleApp_Flash_DstAddr.addr.shortAddr = SAMPLEAPP_FLASH_GROUP; // Fill out the endpoint description. SampleApp_epDesc.endPoint = SAMPLEAPP_ENDPOINT; SampleApp_epDesc.task_id = &SampleApp_TaskID; SampleApp_epDesc.simpleDesc = (SimpleDescriptionFormat_t *)&SampleApp_SimpleDesc; SampleApp_epDesc.latencyReq = noLatencyReqs; // Register the endpoint description with the AF afRegister( &SampleApp_epDesc ); // Register for all key events - This app will handle all key events RegisterForKeys( SampleApp_TaskID ); /*分组信息初始化*/ SampleApp_Group.ID = 0x0001; osal_memcpy( SampleApp_Group.name, "Group 1", 7 ); aps_AddGroup( SAMPLEAPP_ENDPOINT, &SampleApp_Group ); #if defined ( LCD_SUPPORTED ) HalLcdWriteString( "SampleApp", HAL_LCD_LINE_1 ); #endif }
/*================================================================================================= * @fn rxStartIsr * * @brief First ISR state for receiving a packet - compute packet length, allocate * buffer, initialize buffer. Acknowledgements are handled immediately without * allocating a buffer. * * @param none * * @return none *================================================================================================= */ static void rxStartIsr(void) { uint8 addrLen; uint8 ackWithPending; uint8 dstAddrMode; uint8 srcAddrMode; uint8 mhrLen = 0; MAC_ASSERT(!macRxActive); /* receive on top of receive */ /* indicate rx is active */ macRxActive = MAC_RX_ACTIVE_STARTED; /* * For bullet proof functionality, need to see if the receiver was just turned off. * The logic to request turning off the receiver, disables interrupts and then checks * the value of macRxActive. If it is TRUE, the receiver will not be turned off. * * There is a small hole though. It's possible to attempt turning off the receiver * in the window from when the receive interrupt fires and the point where macRxActive * is set to TRUE. To plug this hole, the on/off status must be tested *after* * macRxActive has been set. If the receiver is off at this point, there is nothing * in the RX fifo and the receive is simply aborted. * * Also, there are some considerations in case a hard disable just happened. Usually, * the receiver will just be off at this point after a hard disable. The check described * above will account for this case too. However, if a hard disable were immediately * followed by an enable, the receiver would be on. To catch this case, the receive * FIFO is also tested to see if it is empty. Recovery is identical to the other cases. */ if (!macRxOnFlag || MAC_RADIO_RX_FIFO_IS_EMPTY()) { /* reset active flag */ macRxActive = MAC_RX_ACTIVE_NO_ACTIVITY; /* * To be absolutely bulletproof, must make sure no transmit queue'ed up during * the tiny, tiny window when macRxActive was not zero. */ rxPostRxUpdates(); /* return immediately from here */ return; } /* * If interrupts are held off for too long it's possible the previous "transmit done" * callback is pending. If this is the case, it needs to be completed before * continuing with the receive logic. */ MAC_RADIO_FORCE_TX_DONE_IF_PENDING(); /* * It's possible receive logic is still waiting for confirmation of an ACK that went out * for the previous receive. This is OK but the callback needs to be canceled at this point. * That callback execute receive cleanup logic that will run at the completion * of *this* receive. Also, it is important the flag for the outgoing ACK to be cleared. */ MAC_RADIO_CANCEL_ACK_TX_DONE_CALLBACK(); macRxOutgoingAckFlag = 0; /* * Make a module-local copy of macRxFilter. This prevents the selected * filter from changing in the middle of a receive. */ rxFilter = macRxFilter; /*------------------------------------------------------------------------------- * Read initial frame information from FIFO. * * This code is not triggered until the following are in the RX FIFO: * frame length - one byte containing length of MAC frame (excludes this field) * frame control field - two bytes defining frame type, addressing fields, control flags * sequence number - one byte unique sequence identifier * additional two bytes - these bytes are available in case the received frame is an ACK, * if so, the frame can be verified and responded to immediately, * if not an ACK, these bytes will be processed normally */ /* read frame length, frame control field, and sequence number from FIFO */ MAC_RADIO_READ_RX_FIFO(rxBuf, MAC_PHY_PHR_LEN + MAC_FCF_FIELD_LEN + MAC_SEQ_NUM_FIELD_LEN); /* bytes to read from FIFO equals frame length minus length of MHR fields just read from FIFO */ rxUnreadLen = (rxBuf[0] & PHY_PACKET_SIZE_MASK) - MAC_FCF_FIELD_LEN - MAC_SEQ_NUM_FIELD_LEN; /* * Workaround for chip bug #1547. The receive buffer can sometimes be corrupted by hardware. * This usually occurs under heavy traffic. If a corrupted receive buffer is detected * the entire receive buffer is flushed. */ if ((rxUnreadLen > (MAC_A_MAX_PHY_PACKET_SIZE - MAC_FCF_FIELD_LEN - MAC_SEQ_NUM_FIELD_LEN)) || (MAC_FRAME_TYPE(&rxBuf[1]) > MAC_FRAME_TYPE_MAX_VALID)) { MAC_RADIO_FLUSH_RX_FIFO(); rxDone(); return; } /*------------------------------------------------------------------------------- * Process ACKs. * * If this frame is an ACK, process it immediately and exit from here. * If this frame is not an ACK and transmit is listening for an ACK, let * the transmit logic know an non-ACK was received so transmit can complete. * * In promiscuous mode ACKs are treated like any other frame. */ if ((MAC_FRAME_TYPE(&rxBuf[1]) == MAC_FRAME_TYPE_ACK) && (rxPromiscuousMode == PROMISCUOUS_MODE_OFF)) { halIntState_t s; uint8 fcsBuf[MAC_FCF_FIELD_LEN]; /* * There are guaranteed to be two unread bytes in the FIFO. By defintion, for ACK frames * these two bytes will be the FCS. */ /* read FCS from FIFO (threshold set so bytes are guaranteed to be there) */ MAC_RADIO_READ_RX_FIFO(fcsBuf, MAC_FCS_FIELD_LEN); /* * This critical section ensures that the ACK timeout won't be triggered in the * middle of receiving the ACK frame. */ HAL_ENTER_CRITICAL_SECTION(s); /* see if transmit is listening for an ACK */ if (macTxActive == MAC_TX_ACTIVE_LISTEN_FOR_ACK) { MAC_ASSERT(pMacDataTx != NULL); /* transmit buffer must be present */ /* record link quality metrics for the receive ACK */ { int8 rssiDbm; uint8 corr; rssiDbm = PROPRIETARY_FCS_RSSI(fcsBuf) + MAC_RADIO_RSSI_OFFSET; MAC_RADIO_RSSI_LNA_OFFSET(rssiDbm); corr = PROPRIETARY_FCS_CORRELATION_VALUE(fcsBuf); pMacDataTx->internal.mpduLinkQuality = macRadioComputeLQI(rssiDbm, corr); pMacDataTx->internal.correlation = corr; pMacDataTx->internal.rssi= rssiDbm; } /* * It's okay if the ACK timeout is triggered here. The callbacks for ACK received * or ACK not received will check "macTxActive" flag before taking any actions. */ HAL_EXIT_CRITICAL_SECTION(s); /* * An ACK was received so transmit logic needs to know. If the FCS failed, * the transmit logic still needs to know. In that case, treat the frame * as a non-ACK to complete the active transmit. */ if (PROPRIETARY_FCS_CRC_OK(fcsBuf)) { /* call transmit logic to indicate ACK was received */ macTxAckReceivedCallback(MAC_SEQ_NUMBER(&rxBuf[1]), MAC_FRAME_PENDING(&rxBuf[1])); } else { macTxAckNotReceivedCallback(); } } else { HAL_EXIT_CRITICAL_SECTION(s); } /* receive is done, exit from here */ rxDone(); return; } else if (macTxActive == MAC_TX_ACTIVE_LISTEN_FOR_ACK) { macTxAckNotReceivedCallback(); } /*------------------------------------------------------------------------------- * Apply filtering. * * For efficiency, see if filtering is even 'on' before processing. Also test * to make sure promiscuous mode is disabled. If promiscuous mode is enabled, * do not apply filtering. */ if ((rxFilter != RX_FILTER_OFF) && !rxPromiscuousMode) { if (/* filter all frames */ (rxFilter == RX_FILTER_ALL) || /* filter non-beacon frames */ ((rxFilter == RX_FILTER_NON_BEACON_FRAMES) && (MAC_FRAME_TYPE(&rxBuf[1]) != MAC_FRAME_TYPE_BEACON)) || /* filter non-command frames */ ((rxFilter == RX_FILTER_NON_COMMAND_FRAMES) && ((MAC_FRAME_TYPE(&rxBuf[1]) != MAC_FRAME_TYPE_COMMAND)))) { /* discard rest of frame */ rxDiscardFrame(); return; } } /*------------------------------------------------------------------------------- * Compute length of addressing fields. Compute payload length. */ /* decode addressing modes */ dstAddrMode = MAC_DEST_ADDR_MODE(&rxBuf[1]); srcAddrMode = MAC_SRC_ADDR_MODE(&rxBuf[1]); /* * Workaround for chip bug #1547. The receive buffer can sometimes be corrupted by hardware. * This usually occurs under heavy traffic. If a corrupted receive buffer is detected * the entire receive buffer is flushed. */ if (macChipVersion == REV_A) { if ((srcAddrMode == ADDR_MODE_RESERVERED) || (dstAddrMode == ADDR_MODE_RESERVERED)) { MAC_RADIO_FLUSH_RX_FIFO(); rxDone(); return; } } /* * Compute the addressing field length. A lookup table based on addressing * mode is used for efficiency. If the source address is present and the * frame is intra-PAN, the PAN Id is not repeated. In this case, the address * length is adjusted to match the smaller length. */ addrLen = macRxAddrLen[dstAddrMode] + macRxAddrLen[srcAddrMode]; if ((srcAddrMode != SADDR_MODE_NONE) && MAC_INTRA_PAN(&rxBuf[1])) { addrLen -= MAC_PAN_ID_FIELD_LEN; } /* * If there are not enough unread bytes to include the computed address * plus FCS field, the frame is corrupted and must be discarded. */ if ((addrLen + MAC_FCS_FIELD_LEN) > rxUnreadLen) { /* discard frame and exit */ rxDiscardFrame(); return; } /* aux security header plus payload length is equal to unread bytes minus * address length, minus the FCS */ rxPayloadLen = rxUnreadLen - addrLen - MAC_FCS_FIELD_LEN; /*------------------------------------------------------------------------------- * Allocate memory for the incoming frame. */ if (MAC_SEC_ENABLED(&rxBuf[1])) { /* increase the allocation size of MAC header for security */ mhrLen = MAC_MHR_LEN; } pRxBuf = (macRx_t *) MEM_ALLOC(sizeof(macRx_t) + mhrLen + rxPayloadLen); if (pRxBuf == NULL) { /* Cancel the outgoing TX ACK */ MAC_RADIO_CANCEL_TX_ACK(); /* buffer allocation failed, discard the frame and exit*/ rxDiscardFrame(); return; } /*------------------------------------------------------------------------------- * Set up to process ACK request. Do not ACK if in promiscuous mode. */ ackWithPending = 0; if (!rxPromiscuousMode) { macRxOutgoingAckFlag = MAC_ACK_REQUEST(&rxBuf[1]); } /*------------------------------------------------------------------------------- * Process any ACK request. */ if (macRxOutgoingAckFlag) { halIntState_t s; /* * This critical section ensures that the callback ISR is initiated within time * to guarantee correlation with the strobe. */ HAL_ENTER_CRITICAL_SECTION(s); /* Do not ack data packet with pending more data */ if( MAC_FRAME_TYPE(&rxBuf[1]) == MAC_FRAME_TYPE_COMMAND ) { if( macRxCheckMACPendingCallback()) { /* Check is any mac data pending for end devices */ ackWithPending = MAC_RX_FLAG_ACK_PENDING; } else { if( macSrcMatchIsEnabled ) { /* When autopend is enabled, check if allpending is set to true */ if( MAC_SrcMatchCheckAllPending() == MAC_AUTOACK_PENDING_ALL_ON ) { ackWithPending = MAC_RX_FLAG_ACK_PENDING; } } else { /* When autopend is disabled, check the application pending callback */ if( macRxCheckPendingCallback() ) { ackWithPending = MAC_RX_FLAG_ACK_PENDING; } } } } if( ackWithPending == MAC_RX_FLAG_ACK_PENDING ) { MAC_RADIO_TX_ACK_PEND(); } else { MAC_RADIO_TX_ACK(); } /* request a callback to macRxAckTxDoneCallback() when the ACK transmit has finished */ MAC_RADIO_REQUEST_ACK_TX_DONE_CALLBACK(); HAL_EXIT_CRITICAL_SECTION(s); } /*------------------------------------------------------------------------------- * Populate the receive buffer going up to high-level. */ /* configure the payload buffer * save MAC header pointer regardless of security status. */ pRxBuf->mhr.p = pRxBuf->msdu.p = (uint8 *) (pRxBuf + 1); pRxBuf->mhr.len = pRxBuf->msdu.len = rxPayloadLen; if (MAC_SEC_ENABLED(&rxBuf[1])) { /* Copy FCF and sequence number to RX buffer */ pRxBuf->mhr.len = MAC_FCF_FIELD_LEN + MAC_SEQ_NUM_FIELD_LEN; osal_memcpy(pRxBuf->mhr.p, &rxBuf[1], pRxBuf->mhr.len); pRxBuf->mhr.p += pRxBuf->mhr.len; } /* set internal values */ pRxBuf->mac.srcAddr.addrMode = srcAddrMode; pRxBuf->mac.dstAddr.addrMode = dstAddrMode; pRxBuf->mac.timestamp = MAC_RADIO_BACKOFF_CAPTURE(); pRxBuf->mac.timestamp2 = MAC_RADIO_TIMER_CAPTURE(); /* Special Case for Enhanced Beacon Request which has a different * frame version */ #ifdef FEATURE_ENHANCED_BEACON if( MAC_FRAME_VERSION(&rxBuf[1]) == 2 ) { pRxBuf->internal.frameType = MAC_FRAME_TYPE_INTERNAL_MAC_VERSION_E | \ MAC_FRAME_TYPE(&rxBuf[1]); } else #endif { pRxBuf->internal.frameType = MAC_FRAME_TYPE(&rxBuf[1]); } pRxBuf->mac.dsn = MAC_SEQ_NUMBER(&rxBuf[1]); pRxBuf->internal.flags = INTERNAL_FCF_FLAGS(&rxBuf[1]) | ackWithPending; /*------------------------------------------------------------------------------- * If the processing the addressing fields does not require more bytes from * the FIFO go directly address processing function. Otherwise, configure * interrupt to jump there once bytes are received. */ if (addrLen == 0) { /* no addressing fields to read, prepare for payload interrupts */ pFuncRxState = &rxPayloadIsr; rxPrepPayload(); } else { /* need to read and process addressing fields, prepare for address interrupt */ rxNextLen = addrLen; if (MAC_SEC_ENABLED(&rxBuf[1])) { /* When security is enabled, read off security control field as well */ MAC_RADIO_SET_RX_THRESHOLD(rxNextLen + MAC_SEC_CONTROL_FIELD_LEN); } else { MAC_RADIO_SET_RX_THRESHOLD(rxNextLen); } pFuncRxState = &rxAddrIsr; } }
/************************************************************************************************** * @fn MAC_MlmeSetReq * * @brief This direct execute function sets an attribute value * in the MAC PIB. * * input parameters * * @param pibAttribute - The attribute identifier. * @param pValue - pointer to the attribute value. * * output parameters * * None. * * @return The status of the request, as follows: * MAC_SUCCESS Operation successful. * MAC_UNSUPPORTED_ATTRIBUTE Attribute not found. * ************************************************************************************************** */ uint8 MAC_MlmeSetReq(uint8 pibAttribute, void *pValue) { uint8 i; halIntState_t intState; if (pibAttribute == MAC_BEACON_PAYLOAD) { pMacPib->pBeaconPayload = pValue; return MAC_SUCCESS; } /* look up attribute in PIB table */ if ((i = MAP_macPibIndex(pibAttribute)) == MAC_PIB_INVALID) { return MAC_UNSUPPORTED_ATTRIBUTE; } /* do range check; no range check if min and max are zero */ if ((macPibTbl[i].min != 0) || (macPibTbl[i].max != 0)) { /* if min == max, this is a read-only attribute */ if (macPibTbl[i].min == macPibTbl[i].max) { return MAC_READ_ONLY; } /* check for special cases */ if (pibAttribute == MAC_MAX_FRAME_TOTAL_WAIT_TIME) { if ((*((uint16 *) pValue) < MAC_MAX_FRAME_RESPONSE_MIN) || (*((uint16 *) pValue) > MAC_MAX_FRAME_RESPONSE_MAX)) { return MAC_INVALID_PARAMETER; } } /* range check for general case */ if ((*((uint8 *) pValue) < macPibTbl[i].min) || (*((uint8 *) pValue) > macPibTbl[i].max)) { return MAC_INVALID_PARAMETER; } } /* set value in PIB */ HAL_ENTER_CRITICAL_SECTION(intState); osal_memcpy((uint8 *) pMacPib + macPibTbl[i].offset, pValue, macPibTbl[i].len); HAL_EXIT_CRITICAL_SECTION(intState); /* handle special cases */ switch (pibAttribute) { case MAC_PAN_ID: /* set pan id in radio */ macRadioSetPanID(pMacPib->panId); break; case MAC_SHORT_ADDRESS: /* set short address in radio */ macRadioSetShortAddr(pMacPib->shortAddress); break; case MAC_RX_ON_WHEN_IDLE: /* turn rx on or off */ if (pMacPib->rxOnWhenIdle) { macRxEnable(MAC_RX_WHEN_IDLE); } else { macRxDisable(MAC_RX_WHEN_IDLE); } break; case MAC_LOGICAL_CHANNEL: macRadioSetChannel(pMacPib->logicalChannel); break; case MAC_EXTENDED_ADDRESS: /* set ext address in radio */ macRadioSetIEEEAddr(pMacPib->extendedAddress.addr.extAddr); break; case MAC_PHY_TRANSMIT_POWER_SIGNED: (void)macRadioSetTxPower(pMacPib->phyTransmitPower); break; case MAC_RF4CE_POWER_SAVINGS: pMacPib->rf4cepowerSavings = *(uint8 *)pValue; break; case MAC_FRAME_VERSION_SUPPORT: pMacPib->frameVersionSupport = *(uint8 *)pValue; break; default: break; } return MAC_SUCCESS; }
/* wcn_compressor_out - get the result data from L2 buffer * @ cprs - compressor's pointer * @ pbuf - point to L2 buffer * @ plen - out len * * Retunr 0 if success, else NULL */ INT32 wcn_compressor_out(P_WCN_COMPRESSOR_T cprs, PUINT8 *pbuf, PINT32 plen) { INT32 ret = 0; INT32 tmp_len = 0; if ((!cprs) || (!pbuf) || (!plen)) { STP_DBG_ERR_FUNC("invalid para!\n"); return -1; } // check if there's L1 data need flush to L2 buffer if (cprs->L1_pos > 0) { tmp_len = cprs->L2_buf_sz - cprs->L2_pos; if (cprs->f_compress_en && cprs->handler) { // need compress ret = cprs->handler(cprs->worker, cprs->L1_buf, cprs->L1_pos, &cprs->L2_buf[cprs->L2_pos], &tmp_len, 1); if (!ret) { cprs->crc32 = (crc32(cprs->crc32, cprs->L1_buf, cprs->L1_pos)); cprs->L2_pos += tmp_len; /* Add 8 byte suffix === 32 bits UNCOMPRESS SIZE 32 bits CRC */ *(uint32_t *)(&cprs->L2_buf[cprs->L2_pos]) = (cprs->crc32 ^ 0xffffffffUL); *(uint32_t *)(&cprs->L2_buf[cprs->L2_pos + 4]) = cprs->uncomp_size; cprs->L2_pos += 8; STP_DBG_INFO_FUNC("compress OK!\n"); } else { STP_DBG_ERR_FUNC("compress error!\n"); } } else { // no need compress tmp_len = (cprs->L1_pos > tmp_len) ? tmp_len : cprs->L1_pos; osal_memcpy(&cprs->L2_buf[cprs->L2_pos], cprs->L1_buf, tmp_len); cprs->L2_pos += tmp_len; } cprs->L1_pos = 0; } *pbuf = cprs->L2_buf; *plen = cprs->L2_pos; STP_DBG_INFO_FUNC("0x%08x, len %d\n", (unsigned int)*pbuf, *plen); #if 1 ret = zlib_deflateReset((z_stream*)cprs->worker); if (ret != Z_OK) { STP_DBG_ERR_FUNC("reset failed!\n"); return -2; } #endif return 0; }
/* wcn_compressor_in - put in a raw data, and compress L1 buffer if need * @ cprs - compressor's pointer * @ buf - raw data buffer * @ len - raw data length * @ finish - core dump finish or not, 1: finished; 0: not finish * * Retunr 0 if success, else NULL */ INT32 wcn_compressor_in(P_WCN_COMPRESSOR_T cprs, PUINT8 buf, INT32 len, INT32 finish) { INT32 tmp_len = 0; INT32 ret = 0; if (!cprs) { STP_DBG_ERR_FUNC("invalid para!\n"); return -1; } cprs->uncomp_size += len; // check L1 buf valid space if (len > (cprs->L1_buf_sz - cprs->L1_pos)) { STP_DBG_INFO_FUNC("L1 buffer full\n"); if (cprs->f_compress_en && cprs->handler) { // need compress // compress L1 buffer, and put result to L2 buffer tmp_len = cprs->L2_buf_sz - cprs->L2_pos; ret = cprs->handler(cprs->worker, cprs->L1_buf, cprs->L1_pos, &cprs->L2_buf[cprs->L2_pos], &tmp_len, finish); if (!ret) { cprs->crc32 = (crc32(cprs->crc32, cprs->L1_buf, cprs->L1_pos)); cprs->L2_pos += tmp_len; if (finish) { /* Add 8 byte suffix === 32 bits UNCOMPRESS SIZE 32 bits CRC */ *(uint32_t *)(&cprs->L2_buf[cprs->L2_pos]) = (cprs->crc32 ^ 0xffffffffUL); *(uint32_t *)(&cprs->L2_buf[cprs->L2_pos + 4]) = cprs->uncomp_size; cprs->L2_pos += 8; } STP_DBG_INFO_FUNC("compress OK!\n"); } else { STP_DBG_ERR_FUNC("compress error!\n"); } } else { // no need compress // Flush L1 buffer to L2 buffer STP_DBG_INFO_FUNC("No need do compress, Put to L2 buf\n"); tmp_len = cprs->L2_buf_sz - cprs->L2_pos; tmp_len = (cprs->L1_pos > tmp_len) ? tmp_len : cprs->L1_pos; osal_memcpy(&cprs->L2_buf[cprs->L2_pos], cprs->L1_buf, tmp_len); cprs->L2_pos += tmp_len; } // reset L1 buf pos cprs->L1_pos = 0; // put curren data to L1 buf if (len > cprs->L1_buf_sz) { STP_DBG_ERR_FUNC("len=%d, too long err!\n", len); } else { STP_DBG_INFO_FUNC("L1 Flushed, and Put %d bytes to L1 buf\n", len); osal_memcpy(&cprs->L1_buf[cprs->L1_pos], buf, len); cprs->L1_pos += len; } } else { // put to L1 buffer STP_DBG_INFO_FUNC("Put %d bytes to L1 buf\n", len); osal_memcpy(&cprs->L1_buf[cprs->L1_pos], buf, len); cprs->L1_pos += len; } return ret; }
/************************************************************************************************** * @fn zapUtilReq * * @brief This function packs and sends an RPC NWK request. * * input parameters * * @param cmd - A valid NWK command. * @param req - A buffer containing the contents of the request/response, or NULL. * @param args - Valid argument(s) corresponding to the NWK command. * * output parameters * * @param req - The buffer filled with the contents or success of a response. * @param args - The buffer filled with the contents or success of a response. * * @return SUCCESS or FAILURE. ************************************************************************************************** */ uint8 zapUtilReq(uint8 cmd, uint8 *req, uint8 *args) { uint8 len, cmd0 = (uint8)MT_RPC_CMD_SREQ; uint8 rtrn = SUCCESS; uint8 *pBuf; if (DEV_STATE_INVALID <= devState) { return FAILURE; } switch (cmd) { // SREQ's to ZNP. case MT_UTIL_ASSOC_GET_WITH_ADDRESS: len = Z_EXTADDR_LEN + 2; break; case MT_UTIL_ADDRMGR_NWK_ADDR_LOOKUP: case MT_UTIL_ASSOC_COUNT: len = 2; break; #if SECURE case MT_UTIL_APSME_LINK_KEY_DATA_GET: len = Z_EXTADDR_LEN; break; case MT_UTIL_APSME_LINK_KEY_NV_ID_GET: len = Z_EXTADDR_LEN; break; #endif case MT_UTIL_ASSOC_FIND_DEVICE: len = 1; break; #if defined ZCL_KEY_ESTABLISH case MT_UTIL_ZCL_KEY_EST_INIT_EST: len = 12; break; case MT_UTIL_ZCL_KEY_EST_SIGN: len = *args +1; break; #endif // AREQ's to ZNP. case MT_UTIL_SYNC_REQ: cmd0 = (uint8)MT_RPC_CMD_AREQ; len = 0; break; default: return FAILURE; } cmd0 |= (uint8)MT_RPC_SYS_UTIL; if (NULL == (pBuf = zap_msg_allocate(len, cmd0, cmd))) { return FAILURE; } switch (cmd) { // SREQ's to ZNP. case MT_UTIL_ADDRMGR_NWK_ADDR_LOOKUP: pBuf[0] = *args++; pBuf[1] = *args; break; #if SECURE case MT_UTIL_APSME_LINK_KEY_DATA_GET: (void)osal_memcpy(pBuf, req, Z_EXTADDR_LEN); break; case MT_UTIL_APSME_LINK_KEY_NV_ID_GET: (void)osal_memcpy(pBuf, req, Z_EXTADDR_LEN); break; #endif case MT_UTIL_ASSOC_COUNT: (void)osal_memcpy(pBuf, req, 2); break; case MT_UTIL_ASSOC_FIND_DEVICE: pBuf[0] = *args; break; case MT_UTIL_ASSOC_GET_WITH_ADDRESS: if (NULL == args) { (void)osal_memset(pBuf, 0, Z_EXTADDR_LEN); } else { (void)osal_memcpy(pBuf, args, Z_EXTADDR_LEN); } pBuf[Z_EXTADDR_LEN] = LO_UINT16(assocDevT.shortAddr); pBuf[Z_EXTADDR_LEN+1] = HI_UINT16(assocDevT.shortAddr); break; #if defined ZCL_KEY_ESTABLISH case MT_UTIL_ZCL_KEY_EST_INIT_EST: (void)osal_memcpy(pBuf, req, 12); break; case MT_UTIL_ZCL_KEY_EST_SIGN: *pBuf = *args; (void)osal_memcpy(pBuf+1, req, *args); break; #endif // AREQ's to ZNP. default: break; } if (zapPhySend(zapAppPort, pBuf) == FAILURE) { zap_msg_deallocate(&pBuf); return FAILURE; } switch (cmd) { // SREQ's to ZNP. case MT_UTIL_ADDRMGR_NWK_ADDR_LOOKUP: (void)osal_memcpy(req, pBuf, Z_EXTADDR_LEN); break; #if SECURE case MT_UTIL_APSME_LINK_KEY_DATA_GET: if (SUCCESS == (rtrn = *pBuf)) { APSME_LinkKeyData_t *pData = (APSME_LinkKeyData_t *)args; uint8 *ptr = pBuf+1; // copy key data (void)osal_memcpy(pData->key, ptr, SEC_KEY_LEN); ptr += SEC_KEY_LEN; pData->txFrmCntr = BUILD_UINT32(ptr[0], ptr[1], ptr[2], ptr[3]); ptr += 4; pData->rxFrmCntr = BUILD_UINT32(ptr[0], ptr[1], ptr[2], ptr[3]); } break; case MT_UTIL_APSME_LINK_KEY_NV_ID_GET: if (SUCCESS == (rtrn = *pBuf)) { uint16 *pNvId = (uint16 *)args; uint8 *ptr = pBuf+1; *pNvId = BUILD_UINT16(ptr[0], ptr[1]); } break; #endif case MT_UTIL_ASSOC_COUNT: (void)osal_memcpy(req, pBuf, 2); break; case MT_UTIL_ASSOC_FIND_DEVICE: case MT_UTIL_ASSOC_GET_WITH_ADDRESS: (void)osal_memcpy(req, pBuf, sizeof(associated_devices_t)); break; #if defined ZCL_KEY_ESTABLISH case MT_UTIL_ZCL_KEY_EST_SIGN: #if defined SECURE (void)osal_memcpy(req, pBuf+1, SE_PROFILE_SIGNATURE_LENGTH); #endif case MT_UTIL_ZCL_KEY_EST_INIT_EST: rtrn = *pBuf; break; #endif // AREQ's to ZNP. default: break; } zap_msg_deallocate(&pBuf); return rtrn; }
/********************************************************************* * @fn SimpleProfile_SetParameter * * @brief Set a Simple Profile parameter. * * @param param - Profile parameter ID * @param len - length of data to right * @param value - pointer to data to write. This is dependent on * the parameter ID and WILL be cast to the appropriate * data type (example: data type of uint16 will be cast to * uint16 pointer). * * @return bStatus_t */ bStatus_t SimpleProfile_SetParameter( uint8 param, uint8 len, void *value ) { bStatus_t ret = SUCCESS; switch ( param ) { case SIMPLEPROFILE_CHAR1: if ( len == sizeof ( uint8 ) ) { simpleProfileChar1 = *((uint8*)value); } else { ret = bleInvalidRange; } break; case SIMPLEPROFILE_CHAR2: if ( len == sizeof ( uint8 ) ) { simpleProfileChar2 = *((uint8*)value); } else { ret = bleInvalidRange; } break; case SIMPLEPROFILE_CHAR3: if ( len == sizeof ( uint8 ) ) { simpleProfileChar3 = *((uint8*)value); } else { ret = bleInvalidRange; } break; case SIMPLEPROFILE_CHAR4: if ( len == sizeof ( uint8 ) ) { simpleProfileChar4 = *((uint8*)value); // See if Notification/Indication has been enabled simpleProfile_ProcessCharCfg( simpleProfileChar4Config, &simpleProfileChar4, FALSE ); } else { ret = bleInvalidRange; } break; case SIMPLEPROFILE_CHAR5: if ( len == SIMPLEPROFILE_CHAR5_LEN ) { VOID osal_memcpy( simpleProfileChar5, value, SIMPLEPROFILE_CHAR5_LEN ); } else { ret = bleInvalidRange; } break; default: ret = INVALIDPARAMETER; break; } return ( ret ); }
/********************************************************************* * @brief Set a GAP Role parameter. * * Public function defined in broadcaster.h. */ bStatus_t GAPRole_SetParameter( uint16 param, uint8 len, void *pValue ) { bStatus_t ret = SUCCESS; switch ( param ) { case GAPROLE_ADVERT_ENABLED: if ( len == sizeof( uint8 ) ) { uint8 oldAdvEnabled = gapRole_AdvEnabled; gapRole_AdvEnabled = *((uint8*)pValue); if ( (oldAdvEnabled) && (gapRole_AdvEnabled == FALSE) ) { // Turn off Advertising if ( gapRole_state == GAPROLE_ADVERTISING ) { VOID GAP_EndDiscoverable( gapRole_TaskID ); } } else if ( (oldAdvEnabled == FALSE) && (gapRole_AdvEnabled) ) { // Turn on Advertising if ( (gapRole_state == GAPROLE_STARTED) || (gapRole_state == GAPROLE_WAITING) ) { VOID osal_set_event( gapRole_TaskID, START_ADVERTISING_EVT ); } } } else { ret = bleInvalidRange; } break; case GAPROLE_ADVERT_OFF_TIME: if ( len == sizeof ( uint16 ) ) { gapRole_AdvertOffTime = *((uint16*)pValue); } else { ret = bleInvalidRange; } break; case GAPROLE_ADVERT_DATA: if ( len <= B_MAX_ADV_LEN ) { VOID osal_memset( gapRole_AdvertData, 0, B_MAX_ADV_LEN ); VOID osal_memcpy( gapRole_AdvertData, pValue, len ); gapRole_AdvertDataLen = len; } else { ret = bleInvalidRange; } break; case GAPROLE_SCAN_RSP_DATA: if ( len <= B_MAX_ADV_LEN ) { VOID osal_memset( gapRole_ScanRspData, 0, B_MAX_ADV_LEN ); VOID osal_memcpy( gapRole_ScanRspData, pValue, len ); gapRole_ScanRspDataLen = len; } else { ret = bleInvalidRange; } break; case GAPROLE_ADV_EVENT_TYPE: if ( (len == sizeof ( uint8 )) && (*((uint8*)pValue) <= GAP_ADTYPE_ADV_NONCONN_IND) ) { gapRole_AdvEventType = *((uint8*)pValue); } else { ret = bleInvalidRange; } break; case GAPROLE_ADV_DIRECT_TYPE: if ( (len == sizeof ( uint8 )) && (*((uint8*)pValue) <= ADDRTYPE_PRIVATE_RESOLVE) ) { gapRole_AdvDirectType = *((uint8*)pValue); } else { ret = bleInvalidRange; } break; case GAPROLE_ADV_DIRECT_ADDR: if ( len == B_ADDR_LEN ) { VOID osal_memcpy( gapRole_AdvDirectAddr, pValue, B_ADDR_LEN ) ; } else { ret = bleInvalidRange; } break; case GAPROLE_ADV_CHANNEL_MAP: if ( (len == sizeof ( uint8 )) && (*((uint8*)pValue) <= 0x07) ) { gapRole_AdvChanMap = *((uint8*)pValue); } else { ret = bleInvalidRange; } break; case GAPROLE_ADV_FILTER_POLICY: if ( (len == sizeof ( uint8 )) && (*((uint8*)pValue) <= GAP_FILTER_POLICY_WHITE) ) { gapRole_AdvFilterPolicy = *((uint8*)pValue); } else { ret = bleInvalidRange; } break; default: // The param value isn't part of this profile, try the GAP. if ( (param < TGAP_PARAMID_MAX) && (len == sizeof ( uint16 )) ) { ret = GAP_SetParamValue( param, *((uint16*)pValue) ); } else { ret = INVALIDPARAMETER; } break; } return ( ret ); }
/********************************************************************* * @fn ParkingApp_Init * * @brief Initialization function for the Generic App Task. * This is called during initialization and should contain * any application specific initialization (ie. hardware * initialization/setup, table initialization, power up * notificaiton ... ). * * @param task_id - the ID assigned by OSAL. This ID should be * used to send messages and set timers. * * @return none */ void ParkingApp_Init( uint8 task_id ) { //开始应用初始化,闪灯 //HalLedSet(HAL_LED_1,HAL_LED_MODE_FLASH); HalLedBlink( HAL_LED_1, 10, 50, 1000 ); ParkingApp_TaskID = task_id; ParkingApp_NwkState = DEV_INIT; ParkingApp_TransID = 0; // Device hardware initialization can be added here or in main() (Zmain.c). // If the hardware is application specific - add it here. // If the hardware is other parts of the device add it in main(). #if defined ( BUILD_ALL_DEVICES ) // The "Demo" target is setup to have BUILD_ALL_DEVICES and HOLD_AUTO_START // We are looking at a jumper (defined in ParkingAppHw.c) to be jumpered // together - if they are - we will start up a coordinator. Otherwise, // the device will start as a router. if ( readCoordinatorJumper() ) zgDeviceLogicalType = ZG_DEVICETYPE_COORDINATOR; else zgDeviceLogicalType = ZG_DEVICETYPE_ROUTER; #endif // BUILD_ALL_DEVICES #if defined ( HOLD_AUTO_START ) // HOLD_AUTO_START is a compile option that will surpress ZDApp // from starting the device and wait for the application to // start the device. ZDOInitDevice(0); #endif // Setup for the periodic message's destination address // Broadcast to everyone #if (defined DATABROADCAST && DATABROADCAST == TRUE) ParkingApp_Periodic_DstAddr.addrMode = (afAddrMode_t)AddrBroadcast; //afAddr16Bit; ParkingApp_Periodic_DstAddr.addr.shortAddr = 0xFFFF; // 0x0000; #else ParkingApp_Periodic_DstAddr.addrMode = (afAddrMode_t)afAddr16Bit; ParkingApp_Periodic_DstAddr.addr.shortAddr = 0x0000; #endif ParkingApp_Periodic_DstAddr.endPoint = PARKINGAPP_ENDPOINT; // Fill out the endpoint description. ParkingApp_epDesc.endPoint = PARKINGAPP_ENDPOINT; ParkingApp_epDesc.task_id = &ParkingApp_TaskID; ParkingApp_epDesc.simpleDesc = (SimpleDescriptionFormat_t *)&ParkingApp_SimpleDesc; ParkingApp_epDesc.latencyReq = noLatencyReqs; // Register the endpoint description with the AF afRegister( &ParkingApp_epDesc ); // Register for all key events - This app will handle all key events RegisterForKeys( ParkingApp_TaskID ); osal_pwrmgr_task_state( ParkingApp_TaskID, PWRMGR_CONSERVE ); // Set TXPOWER // MAC_MlmeSetReq( ZMacPhyTransmitPower, &txPower ); // By default, all devices start out in Group 1 ParkingApp_Group.ID = 0x0005; osal_memcpy( ParkingApp_Group.name, "Group 1", 7 ); aps_AddGroup( PARKINGAPP_ENDPOINT, &ParkingApp_Group ); }
/********************************************************************* * @fn gapRole_ProcessGAPMsg * * @brief Process an incoming task message. * * @param pMsg - message to process * * @return none */ static void gapRole_ProcessGAPMsg( gapEventHdr_t *pMsg ) { uint8 notify = FALSE; // State changed notify the app? (default no) switch ( pMsg->opcode ) { case GAP_DEVICE_INIT_DONE_EVENT: { gapDeviceInitDoneEvent_t *pPkt = (gapDeviceInitDoneEvent_t *)pMsg; bStatus_t stat = pPkt->hdr.status; if ( stat == SUCCESS ) { // Save off the information VOID osal_memcpy( gapRole_bdAddr, pPkt->devAddr, B_ADDR_LEN ); gapRole_state = GAPROLE_STARTED; // Update the advertising data stat = GAP_UpdateAdvertisingData( gapRole_TaskID, TRUE, gapRole_AdvertDataLen, gapRole_AdvertData ); } if ( stat != SUCCESS ) { gapRole_state = GAPROLE_ERROR; } notify = TRUE; } break; case GAP_ADV_DATA_UPDATE_DONE_EVENT: { gapAdvDataUpdateEvent_t *pPkt = (gapAdvDataUpdateEvent_t *)pMsg; if ( pPkt->hdr.status == SUCCESS ) { if ( pPkt->adType ) { // Setup the Response Data pPkt->hdr.status = GAP_UpdateAdvertisingData( gapRole_TaskID, FALSE, gapRole_ScanRspDataLen, gapRole_ScanRspData ); } else { // Start advertising VOID osal_set_event( gapRole_TaskID, START_ADVERTISING_EVT ); } } if ( pPkt->hdr.status != SUCCESS ) { // Set into Error state gapRole_state = GAPROLE_ERROR; notify = TRUE; } } break; case GAP_MAKE_DISCOVERABLE_DONE_EVENT: case GAP_END_DISCOVERABLE_DONE_EVENT: { gapMakeDiscoverableRspEvent_t *pPkt = (gapMakeDiscoverableRspEvent_t *)pMsg; if ( pPkt->hdr.status == SUCCESS ) { if ( pMsg->opcode == GAP_MAKE_DISCOVERABLE_DONE_EVENT ) { gapRole_state = GAPROLE_ADVERTISING; } else // GAP_END_DISCOVERABLE_DONE_EVENT { if ( gapRole_AdvertOffTime != 0 ) { if ( ( gapRole_AdvEnabled ) ) { VOID osal_start_timerEx( gapRole_TaskID, START_ADVERTISING_EVT, gapRole_AdvertOffTime ); } } else { // Since gapRole_AdvertOffTime is set to 0, the device should not // automatically become discoverable again after a period of time. // Set enabler to FALSE; device will become discoverable again when // this value gets set to TRUE gapRole_AdvEnabled = FALSE; } // In the Advertising Off period gapRole_state = GAPROLE_WAITING; } } else { gapRole_state = GAPROLE_ERROR; } notify = TRUE; } break; default: break; } if ( notify == TRUE ) { // Notify the application if ( pGapRoles_AppCGs && pGapRoles_AppCGs->pfnStateChange ) { pGapRoles_AppCGs->pfnStateChange( gapRole_state ); } } }
/********************************************************************* * @fn SimpleProfile_SetParameter * * @brief Set a Simple Profile parameter. * * @param param - Profile parameter ID * @param len - length of data to right * @param value - pointer to data to write. This is dependent on * the parameter ID and WILL be cast to the appropriate * data type (example: data type of uint16 will be cast to * uint16 pointer). * * @return bStatus_t */ bStatus_t SimpleProfile_SetParameter(uint8 param, uint8 len, void *value) { bStatus_t ret = SUCCESS; switch (param) { case SIMPLEPROFILE_CHAR1: if (len == SIMPLEPROFILE_CHAR1_LEN) { VOID osal_memcpy(simpleProfileChar1, value, SIMPLEPROFILE_CHAR1_LEN); } else { ret = bleInvalidRange; } break; case SIMPLEPROFILE_CHAR2: if (len ==SIMPLEPROFILE_CHAR2_LEN) { VOID osal_memcpy(simpleProfileChar2, value, SIMPLEPROFILE_CHAR2_LEN); } else { ret = bleInvalidRange; } break; case SIMPLEPROFILE_CHAR3: if (len == SIMPLEPROFILE_CHAR3_LEN) { VOID osal_memcpy(simpleProfileChar3, value, SIMPLEPROFILE_CHAR3_LEN); } else { ret = bleInvalidRange; } break; case SIMPLEPROFILE_CHAR4: if (len == sizeof(uint8)) { simpleProfileChar4 = *((uint8*) value); // See if Notification has been enabled GATTServApp_ProcessCharCfg(simpleProfileChar4Config, &simpleProfileChar4, FALSE, simpleProfileAttrTbl, GATT_NUM_ATTRS( simpleProfileAttrTbl ), INVALID_TASK_ID); } else { ret = bleInvalidRange; } break; case SIMPLEPROFILE_CHAR5: if (len == SIMPLEPROFILE_CHAR5_LEN) { VOID osal_memcpy(simpleProfileChar5, value, SIMPLEPROFILE_CHAR5_LEN); } else { ret = bleInvalidRange; } break; case SIMPLEPROFILE_CHAR6: if (len == SIMPLEPROFILE_CHAR6_LEN) { VOID osal_memcpy(simpleProfileChar6, value, SIMPLEPROFILE_CHAR6_LEN); } else { ret = bleInvalidRange; } break; case SIMPLEPROFILE_CHAR7: if (len == SIMPLEPROFILE_CHAR7_LEN) { VOID osal_memcpy(simpleProfileChar7, value, SIMPLEPROFILE_CHAR7_LEN); } else { ret = bleInvalidRange; } break; case SIMPLEPROFILE_CHAR8: if (len == SIMPLEPROFILE_CHAR8_LEN) { VOID osal_memcpy(simpleProfileChar8, value, SIMPLEPROFILE_CHAR8_LEN); } else { ret = bleInvalidRange; } break; default: ret = INVALIDPARAMETER; break; } return (ret); }
/************************************************************************************************** * @fn pulseDataRx * * @brief This function is called by pulseAfMsgRx() to process incoming PULSE data. * * input parameters * * @param msg - A pointer to the afIncomingMSGPacket_t packet. * * output parameters * * None. * * @return None. ************************************************************************************************** */ static void pulseDataRx(afIncomingMSGPacket_t *msg) { uint8 fcs = 0, idx; // Last announce broadcast to stop must have expired before a parent could forward to a ZED. if (INVALID_NODE_ADDR == pulseAddr) { (void)osal_set_event(pulseTaskId, PULSE_EVT_ANN); } pulseBuf[PULSE_SOP_IDX] = PULSE_SOP_VAL; pulseBuf[PULSE_ADR_LSB] = LO_UINT16(msg->srcAddr.addr.shortAddr); pulseBuf[PULSE_ADR_MSB] = HI_UINT16(msg->srcAddr.addr.shortAddr); // 1st byte of message is skipped - CMD is always 0 for data. (void)osal_memcpy(pulseBuf+PULSE_DAT_OFF, msg->cmd.Data+1, PULSE_DAT_LEN-1); //MHMS copies one buffer to another for (idx = PULSE_ADR_LSB; idx < PULSE_FCS_IDX; idx++) { fcs ^= pulseBuf[idx]; } pulseBuf[idx] = fcs; uint8 deviceBPM; uint8 parentAddrLSB; uint8 parentAddrMSB; uint8 zsensorBuf[15]; parentAddrLSB= pulseBuf[11]; parentAddrMSB= pulseBuf[12]; if(pulseBuf[13] == CHECK_IN_INACTIVE){ deviceBPM = pulseBuf[15]; } else{ deviceBPM = 5; } //deviceVolt = 0xFF; //Start of Frame Delimiter zsensorBuf[0]=0xFE; zsensorBuf[1]=10; zsensorBuf[2]=LO_UINT16(0x8746); zsensorBuf[3]=HI_UINT16(0x8746); //Source Address zsensorBuf[4] = LO_UINT16(msg->srcAddr.addr.shortAddr); zsensorBuf[5] = HI_UINT16(msg->srcAddr.addr.shortAddr); zsensorBuf[6]=LO_UINT16(2); //MHMS are 6 - 9 being used for anything? zsensorBuf[7]=HI_UINT16(2); zsensorBuf[8]=LO_UINT16(4); zsensorBuf[9]=HI_UINT16(4); //Temperature and Voltage Data zsensorBuf[10]= deviceBPM; zsensorBuf[11]= deviceBPM; //deviceVolt; //Parent Address zsensorBuf[12]=parentAddrLSB; zsensorBuf[13]=parentAddrMSB; //FCS Check on the middle 13 bytes zsensorBuf[14] = calcFCS(&zsensorBuf[1], 13 ); HalUARTWrite(PULSE_PORT, zsensorBuf, 15); //For communicating with the Zigbee sensor Monitor /* //MHMS USB communication with Pulse sensor Processor application uint8 BPMBuf[7] = {'B',0,0,0,10,13}; uint8 IBIBuf[7] = {'Q',0,0,0,10,13}; uint8 SignalBuf[7] = {'S',0,0,0,10,13}; //conversion Signal Dec to ASCII uint16 temp = (BUILD_UINT16(pulseBuf[16], pulseBuf[17])) - 400; if(temp > 999){ SignalBuf[1] = '9'; SignalBuf[2] = '9'; SignalBuf[3] = '9'; } else { SignalBuf[1] = (uint8)((temp/100)+ 48); SignalBuf[2] = (uint8)((((temp%100) - (temp % 100)%10)/10) + 48); SignalBuf[3] = (uint8)(((temp % 100)%10)+ 48); } //conversion BPM Dec to ASCII temp = (uint16)pulseBuf[14]; BPMBuf[1] = (uint8)((temp/100)+ 48); BPMBuf[2] = (uint8)((((temp%100) - (temp % 100)%10)/10) + 48); BPMBuf[3] = (uint8)(((temp % 100)%10)+ 48); //conversion IBI Dec to ASCII temp = (uint16)pulseBuf[19]; IBIBuf[1] = (uint8)((temp/100)+ 48); IBIBuf[2] = (uint8)((((temp%100) - (temp % 100)%10)/10) + 48); IBIBuf[3] = (uint8)(((temp % 100)%10)+ 48); //HalUARTWrite(PULSE_PORT, SignalBuf, 6); // HalUARTWrite(PULSE_PORT, BPMBuf, 6); // HalUARTWrite(PULSE_PORT, IBIBuf, 6); */ }
/********************************************************************* * @fn simpleProfile_ReadAttrCB * * @brief Read an attribute. * * @param connHandle - connection message was received on * @param pAttr - pointer to attribute * @param pValue - pointer to data to be read * @param pLen - length of data to be read * @param offset - offset of the first octet to be read * @param maxLen - maximum length of data to be read * * @return Success or Failure */ static uint8 simpleProfile_ReadAttrCB(uint16 connHandle, gattAttribute_t *pAttr, uint8 *pValue, uint8 *pLen, uint16 offset, uint8 maxLen) { bStatus_t status = SUCCESS; // If attribute permissions require authorization to read, return error if (gattPermitAuthorRead( pAttr->permissions )) { // Insufficient authorization return (ATT_ERR_INSUFFICIENT_AUTHOR); } // Make sure it's not a blob operation (no attributes in the profile are long) if (offset > 0) { return (ATT_ERR_ATTR_NOT_LONG); } if (pAttr->type.len == ATT_BT_UUID_SIZE) { // 16-bit UUID uint16 uuid = BUILD_UINT16( pAttr->type.uuid[0], pAttr->type.uuid[1]); switch (uuid) { // No need for "GATT_SERVICE_UUID" or "GATT_CLIENT_CHAR_CFG_UUID" cases; // gattserverapp handles those reads // characteristics 1 and 2 have read permissions // characteritisc 3 does not have read permissions; therefore it is not // included here // characteristic 4 does not have read permissions, but because it // can be sent as a notification, it is included here case SIMPLEPROFILE_CHAR1_UUID: *pLen = SIMPLEPROFILE_CHAR1_LEN; VOID osal_memcpy(pValue, pAttr->pValue, SIMPLEPROFILE_CHAR1_LEN); break; case SIMPLEPROFILE_CHAR2_UUID: *pLen = SIMPLEPROFILE_CHAR2_LEN; VOID osal_memcpy(pValue, pAttr->pValue, SIMPLEPROFILE_CHAR2_LEN); break; case SIMPLEPROFILE_CHAR3_UUID: *pLen = SIMPLEPROFILE_CHAR3_LEN; VOID osal_memcpy(pValue, pAttr->pValue, SIMPLEPROFILE_CHAR3_LEN); break; case SIMPLEPROFILE_CHAR4_UUID: *pLen = 1; pValue[0] = *pAttr->pValue; break; case SIMPLEPROFILE_CHAR5_UUID: *pLen = SIMPLEPROFILE_CHAR5_LEN; VOID osal_memcpy(pValue, pAttr->pValue, SIMPLEPROFILE_CHAR5_LEN); break; case SIMPLEPROFILE_CHAR6_UUID: *pLen = SIMPLEPROFILE_CHAR6_LEN; VOID osal_memcpy(pValue, pAttr->pValue, SIMPLEPROFILE_CHAR6_LEN); break; case SIMPLEPROFILE_CHAR7_UUID: *pLen = SIMPLEPROFILE_CHAR7_LEN; VOID osal_memcpy(pValue, pAttr->pValue, SIMPLEPROFILE_CHAR7_LEN); break; case SIMPLEPROFILE_CHAR8_UUID: *pLen = SIMPLEPROFILE_CHAR8_LEN; VOID osal_memcpy(pValue, pAttr->pValue, SIMPLEPROFILE_CHAR8_LEN); break; default: // Should never get here! (characteristics 3 and 4 do not have read permissions) *pLen = 0; status = ATT_ERR_ATTR_NOT_FOUND; break; } } else { // 128-bit UUID *pLen = 0; status = ATT_ERR_INVALID_HANDLE; } return (status); }
/******************************************************************************************************** * @fn ZMacSecurityGetReq * * @brief Read a MAC Security PIB attribute. * * @param attr - PIB attribute to get * @param value - pointer to the buffer to store the attribute * * @return status ********************************************************************************************************/ uint8 ZMacSecurityGetReq( uint8 attr, uint8 *value ) { uint8 keyIndex, entry, status; uint8 *ptr; ptr = (uint8 *) value; switch (attr) { case ZMacKeyIdLookupEntry: keyIndex = *ptr++; /* key_index */ entry = *ptr++; /* key_id_lookup_index */ /* Transform byte array to propriety PIB struct */ ((macSecurityPibKeyIdLookupEntry_t *)value)->key_id_lookup_index = entry; ((macSecurityPibKeyIdLookupEntry_t *)value)->key_index = keyIndex; break; case ZMacKeyDeviceEntry: keyIndex = *ptr++; /* key_index */ entry = *ptr++; /* key_device_index */ /* Transform byte array to propriety PIB struct */ ((macSecurityPibKeyDeviceEntry_t *)value)->key_device_index = entry; ((macSecurityPibKeyDeviceEntry_t *)value)->key_index = keyIndex; break; case ZMacKeyUsageEntry: keyIndex = *ptr++; /* key_index */ entry = *ptr++; /* key_key_usage_index */ /* Transform byte array to propriety PIB struct */ ((macSecurityPibKeyUsageEntry_t *)value)->key_key_usage_index = entry; ((macSecurityPibKeyUsageEntry_t *)value)->key_index = keyIndex; break; case ZMacKeyEntry: keyIndex = *ptr++; /* key_index */ /* Transform byte array to propriety PIB struct */ ((macSecurityPibKeyEntry_t *)value)->key_index = keyIndex; break; case ZMacDeviceEntry: entry = *ptr++; /* device_index */ /* Transform byte array to propriety PIB struct */ ((macSecurityPibDeviceEntry_t *)value)->device_index = entry; break; case ZMacSecurityLevelEntry: entry = *ptr++; /* security_level_index */ /* Transform byte array to propriety PIB struct */ ((macSecurityPibSecurityLevelEntry_t *)value)->security_level_index = entry; break; } status = (ZMacStatus_t) MAC_MlmeGetSecurityReq( attr, value ); ptr = (uint8 *) value; switch (attr) { case ZMacKeyIdLookupEntry: *ptr++ = keyIndex; /* key_index */ *ptr++ = entry; /* key_id_lookup_index */ /* Transform propriety PIB struct to byte array */ osal_memcpy(ptr, &((macSecurityPibKeyIdLookupEntry_t *)value)->macKeyIdLookupEntry, sizeof(keyIdLookupDescriptor_t)); break; case ZMacKeyDeviceEntry: *ptr++ = keyIndex; /* key_index */ *ptr++ = entry; /* key_device_index */ /* Transform propriety PIB struct to byte array */ osal_memcpy(ptr, &((macSecurityPibKeyDeviceEntry_t *)value)->macKeyDeviceEntry, sizeof(keyDeviceDescriptor_t)); break; case ZMacKeyUsageEntry: *ptr++ = keyIndex; /* key_index */ *ptr++ = entry; /* key_key_usage_index */ /* Transform propriety PIB struct to byte array */ osal_memcpy(ptr, &((macSecurityPibKeyUsageEntry_t *)value)->macKeyUsageEntry, sizeof(keyUsageDescriptor_t)); break; case ZMacKeyEntry: *ptr++ = keyIndex; /* key_index */ /* Transform propriety PIB struct to byte array */ osal_memcpy(ptr, &((macSecurityPibKeyEntry_t *)value)->keyEntry, MAC_KEY_MAX_LEN); break; case ZMacDeviceEntry: *ptr++ = entry; /* device_index */ /* Transform propriety PIB struct to byte array */ osal_memcpy(ptr, &((macSecurityPibDeviceEntry_t *)value)->macDeviceEntry, sizeof(deviceDescriptor_t)); break; case ZMacSecurityLevelEntry: *ptr++ = entry; /* security_level_index */ /* Transform propriety PIB struct to byte array */ osal_memcpy(ptr, &((macSecurityPibSecurityLevelEntry_t *)value)->macSecurityLevelEntry, sizeof(securityLevelDescriptor_t)); break; } return status; }
/* INT32 WMT_ioctl(struct inode *inode, struct file *filp, UINT32 cmd, unsigned long arg) */ long WMT_unlocked_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) { #define WMT_IOC_MAGIC 0xa0 #define WMT_IOCTL_SET_PATCH_NAME _IOW(WMT_IOC_MAGIC, 4, char*) #define WMT_IOCTL_SET_STP_MODE _IOW(WMT_IOC_MAGIC, 5, int) #define WMT_IOCTL_FUNC_ONOFF_CTRL _IOW(WMT_IOC_MAGIC, 6, int) #define WMT_IOCTL_LPBK_POWER_CTRL _IOW(WMT_IOC_MAGIC, 7, int) #define WMT_IOCTL_LPBK_TEST _IOWR(WMT_IOC_MAGIC, 8, char*) #define WMT_IOCTL_GET_CHIP_INFO _IOR(WMT_IOC_MAGIC, 12, int) #define WMT_IOCTL_SET_LAUNCHER_KILL _IOW(WMT_IOC_MAGIC, 13, int) #define WMT_IOCTL_SET_PATCH_NUM _IOW(WMT_IOC_MAGIC, 14, int) #define WMT_IOCTL_SET_PATCH_INFO _IOW(WMT_IOC_MAGIC, 15, char*) #define WMT_IOCTL_PORT_NAME _IOWR(WMT_IOC_MAGIC, 20, char*) #define WMT_IOCTL_WMT_CFG_NAME _IOWR(WMT_IOC_MAGIC, 21, char*) #define WMT_IOCTL_WMT_QUERY_CHIPID _IOR(WMT_IOC_MAGIC, 22, int) #define WMT_IOCTL_WMT_TELL_CHIPID _IOW(WMT_IOC_MAGIC, 23, int) #define WMT_IOCTL_WMT_COREDUMP_CTRL _IOW(WMT_IOC_MAGIC, 24, int) #define WMT_IOCTL_WMT_STP_ASSERT_CTRL _IOW(WMT_IOC_MAGIC, 27, int) INT32 iRet = 0; UINT8 pBuffer[NAME_MAX + 1]; WMT_DBG_FUNC("cmd (%u), arg (0x%lx)\n", cmd, arg); switch (cmd) { case WMT_IOCTL_SET_PATCH_NAME: /* patch location */ { if (copy_from_user(pBuffer, (void *)arg, NAME_MAX)) { iRet = -EFAULT; break; } pBuffer[NAME_MAX] = '\0'; wmt_lib_set_patch_name(pBuffer); } break; case WMT_IOCTL_SET_STP_MODE: /* stp/hif/fm mode */ /* set hif conf */ do { P_OSAL_OP pOp; MTK_WCN_BOOL bRet; P_OSAL_SIGNAL pSignal = NULL; P_WMT_HIF_CONF pHif = NULL; iRet = wmt_lib_set_hif(arg); if (0 != iRet) { WMT_INFO_FUNC("wmt_lib_set_hif fail (%lu)\n", arg); break; } pOp = wmt_lib_get_free_op(); if (!pOp) { WMT_INFO_FUNC("get_free_lxop fail\n"); break; } pSignal = &pOp->signal; pOp->op.opId = WMT_OPID_HIF_CONF; pHif = wmt_lib_get_hif(); osal_memcpy(&pOp->op.au4OpData[0], pHif, sizeof(WMT_HIF_CONF)); pOp->op.u4InfoBit = WMT_OP_HIF_BIT; pSignal->timeoutValue = 0; bRet = wmt_lib_put_act_op(pOp); WMT_DBG_FUNC("WMT_OPID_HIF_CONF result(%d)\n", bRet); iRet = (MTK_WCN_BOOL_FALSE == bRet) ? -EFAULT : 0; } while (0); break; case WMT_IOCTL_FUNC_ONOFF_CTRL: /* test turn on/off func */ do { MTK_WCN_BOOL bRet = MTK_WCN_BOOL_FALSE; if (arg & 0x80000000) { bRet = mtk_wcn_wmt_func_on(arg & 0xF); } else { bRet = mtk_wcn_wmt_func_off(arg & 0xF); } iRet = (MTK_WCN_BOOL_FALSE == bRet) ? -EFAULT : 0; } while (0); break; case WMT_IOCTL_LPBK_POWER_CTRL: /*switch Loopback function on/off arg: bit0 = 1:turn loopback function on bit0 = 0:turn loopback function off */ do { MTK_WCN_BOOL bRet = MTK_WCN_BOOL_FALSE; if (arg & 0x01) { bRet = mtk_wcn_wmt_func_on(WMTDRV_TYPE_LPBK); } else { bRet = mtk_wcn_wmt_func_off(WMTDRV_TYPE_LPBK); } iRet = (MTK_WCN_BOOL_FALSE == bRet) ? -EFAULT : 0; } while (0); break; case WMT_IOCTL_LPBK_TEST: do { P_OSAL_OP pOp; MTK_WCN_BOOL bRet; UINT32 u4Wait; /* UINT8 lpbk_buf[1024] = {0}; */ UINT32 effectiveLen = 0; P_OSAL_SIGNAL pSignal = NULL; if (copy_from_user(&effectiveLen, (void *)arg, sizeof(effectiveLen))) { iRet = -EFAULT; WMT_ERR_FUNC("copy_from_user failed at %d\n", __LINE__); break; } if (effectiveLen > sizeof(gLpbkBuf)) { iRet = -EFAULT; WMT_ERR_FUNC("length is too long\n"); break; } WMT_DBG_FUNC("len = %d\n", effectiveLen); pOp = wmt_lib_get_free_op(); if (!pOp) { WMT_WARN_FUNC("get_free_lxop fail\n"); iRet = -EFAULT; break; } u4Wait = 2000; if (copy_from_user (&gLpbkBuf[0], (void *)arg + sizeof(unsigned long), effectiveLen)) { WMT_ERR_FUNC("copy_from_user failed at %d\n", __LINE__); iRet = -EFAULT; break; } pSignal = &pOp->signal; pOp->op.opId = WMT_OPID_LPBK; pOp->op.au4OpData[0] = effectiveLen; /* packet length */ pOp->op.au4OpData[1] = (size_t) &gLpbkBuf[0]; memcpy(&gLpbkBufLog, &gLpbkBuf[((effectiveLen >= 4) ? effectiveLen - 4 : 0)], 4); pSignal->timeoutValue = MAX_EACH_WMT_CMD; WMT_INFO_FUNC("OPID(%d) type(%d) start\n", pOp->op.opId, pOp->op.au4OpData[0]); if (DISABLE_PSM_MONITOR()) { WMT_ERR_FUNC("wake up failed\n"); wmt_lib_put_op_to_free_queue(pOp); return -1; } bRet = wmt_lib_put_act_op(pOp); ENABLE_PSM_MONITOR(); if (MTK_WCN_BOOL_FALSE == bRet) { WMT_WARN_FUNC("OPID(%d) type(%d) buf tail(0x%08x) fail\n", pOp->op.opId, pOp->op.au4OpData[0], gLpbkBufLog); iRet = -1; break; } else { WMT_INFO_FUNC("OPID(%d) length(%d) ok\n", pOp->op.opId, pOp->op.au4OpData[0]); iRet = pOp->op.au4OpData[0]; if (copy_to_user ((void *)arg + sizeof(unsigned long) + sizeof(UINT8[2048]), gLpbkBuf, iRet)) { iRet = -EFAULT; break; } } } while (0); break; #if 0 case 9: { #define LOG_BUF_SZ 300 UINT8 buf[LOG_BUF_SZ]; INT32 len = 0; INT32 remaining = 0; remaining = mtk_wcn_stp_btm_get_dmp(buf, &len); if (remaining == 0) { WMT_DBG_FUNC("waiting dmp\n"); wait_event_interruptible(dmp_wq, dmp_flag != 0); dmp_flag = 0; remaining = mtk_wcn_stp_btm_get_dmp(buf, &len); /* WMT_INFO_FUNC("len = %d ###%s#\n", len, buf); */ } else { WMT_LOUD_FUNC("no waiting dmp\n"); } if (unlikely((len + sizeof(INT32)) >= LOG_BUF_SZ)) { WMT_ERR_FUNC("len is larger buffer\n"); iRet = -EFAULT; goto fail_exit; } buf[sizeof(INT32) + len] = '\0'; if (copy_to_user((void *)arg, (PUINT8)&len, sizeof(INT32))) { iRet = -EFAULT; goto fail_exit; } if (copy_to_user((void *)arg + sizeof(INT32), buf, len)) { iRet = -EFAULT; goto fail_exit; } } break; case 10: { WMT_INFO_FUNC("Enable combo trace32 dump\n"); wmt_cdev_t32dmp_enable(); WMT_INFO_FUNC("Enable STP debugging mode\n"); mtk_wcn_stp_dbg_enable(); } break; case 11: { WMT_INFO_FUNC("Disable combo trace32 dump\n"); wmt_cdev_t32dmp_disable(); WMT_INFO_FUNC("Disable STP debugging mode\n"); mtk_wcn_stp_dbg_disable(); } break; #endif case 10: { wmt_lib_host_awake_get(); mtk_wcn_stp_coredump_start_ctrl(1); osal_strcpy(pBuffer, "MT662x f/w coredump start-"); if (copy_from_user (pBuffer + osal_strlen(pBuffer), (void *)arg, NAME_MAX - osal_strlen(pBuffer))) { /* osal_strcpy(pBuffer, "MT662x f/w assert core dump start"); */ WMT_ERR_FUNC("copy assert string failed\n"); } pBuffer[NAME_MAX] = '\0'; osal_dbg_assert_aee(pBuffer, pBuffer); } break; case 11: { osal_dbg_assert_aee("MT662x f/w coredump end", "MT662x firmware coredump ends"); wmt_lib_host_awake_put(); } break; case WMT_IOCTL_GET_CHIP_INFO: { if (0 == arg) { return wmt_lib_get_icinfo(WMTCHIN_CHIPID); } else if (1 == arg) { return wmt_lib_get_icinfo(WMTCHIN_HWVER); } else if (2 == arg) { return wmt_lib_get_icinfo(WMTCHIN_FWVER); } } break; case WMT_IOCTL_SET_LAUNCHER_KILL:{ if (1 == arg) { WMT_INFO_FUNC("launcher may be killed,block abnormal stp tx.\n"); wmt_lib_set_stp_wmt_last_close(1); } else { wmt_lib_set_stp_wmt_last_close(0); } } break; case WMT_IOCTL_SET_PATCH_NUM:{ pAtchNum = arg; WMT_INFO_FUNC(" get patch num from launcher = %d\n", pAtchNum); wmt_lib_set_patch_num(pAtchNum); if (pAtchNum > 0) pPatchInfo = kzalloc(sizeof(WMT_PATCH_INFO) *pAtchNum, GFP_ATOMIC); else WMT_ERR_FUNC("patch num == 0!\n"); if (!pPatchInfo) { WMT_ERR_FUNC("allocate memory fail!\n"); break; } } break; case WMT_IOCTL_SET_PATCH_INFO:{ WMT_PATCH_INFO wMtPatchInfo; P_WMT_PATCH_INFO pTemp = NULL; UINT32 dWloadSeq; static UINT32 counter = 0; if (!pPatchInfo) { WMT_ERR_FUNC("NULL patch info pointer\n"); break; } if (copy_from_user(&wMtPatchInfo, (void *)arg, sizeof(WMT_PATCH_INFO))) { WMT_ERR_FUNC("copy_from_user failed at %d\n", __LINE__); iRet = -EFAULT; break; } dWloadSeq = wMtPatchInfo.dowloadSeq; WMT_DBG_FUNC ("current download seq no is %d,patch name is %s,addres info is 0x%02x,0x%02x,0x%02x,0x%02x\n", dWloadSeq, wMtPatchInfo.patchName, wMtPatchInfo.addRess[0], wMtPatchInfo.addRess[1], wMtPatchInfo.addRess[2], wMtPatchInfo.addRess[3]); osal_memcpy(pPatchInfo + dWloadSeq - 1, &wMtPatchInfo, sizeof(WMT_PATCH_INFO)); pTemp = pPatchInfo + dWloadSeq - 1; if (++counter == pAtchNum) { wmt_lib_set_patch_info(pPatchInfo); counter = 0; } } break; case WMT_IOCTL_PORT_NAME:{ INT8 cUartName[NAME_MAX + 1]; if (copy_from_user(cUartName, (void *)arg, NAME_MAX)) { iRet = -EFAULT; break; } cUartName[NAME_MAX] = '\0'; wmt_lib_set_uart_name(cUartName); } break; case WMT_IOCTL_WMT_CFG_NAME: { INT8 cWmtCfgName[NAME_MAX + 1]; if (copy_from_user(cWmtCfgName, (void *)arg, NAME_MAX)) { iRet = -EFAULT; break; } cWmtCfgName[NAME_MAX] = '\0'; wmt_conf_set_cfg_file(cWmtCfgName); } break; case WMT_IOCTL_WMT_QUERY_CHIPID: { #if !(DELETE_HIF_SDIO_CHRDEV) iRet = mtk_wcn_hif_sdio_query_chipid(1); #else iRet = mtk_wcn_wmt_chipid_query(); #endif } break; case WMT_IOCTL_WMT_TELL_CHIPID: { #if !(DELETE_HIF_SDIO_CHRDEV) iRet = mtk_wcn_hif_sdio_tell_chipid(arg); #endif if (0x6628 == arg || 0x6630 == arg) { wmt_lib_merge_if_flag_ctrl(1); } else { wmt_lib_merge_if_flag_ctrl(0); } } break; case WMT_IOCTL_WMT_COREDUMP_CTRL: { if (0 == arg) { mtk_wcn_stp_coredump_flag_ctrl(0); } else { mtk_wcn_stp_coredump_flag_ctrl(1); } } break; case WMT_IOCTL_WMT_STP_ASSERT_CTRL: if (MTK_WCN_BOOL_TRUE == wmt_lib_btm_cb(BTM_TRIGGER_STP_ASSERT_OP)) { WMT_INFO_FUNC("trigger stp assert succeed\n"); iRet = 0; } else { WMT_INFO_FUNC("trigger stp assert failed\n"); iRet = -1; } break; default: iRet = -EINVAL; WMT_WARN_FUNC("unknown cmd (%d)\n", cmd); break; } return iRet; }
/********************************************************************* * @fn SimpleProfile_SetParameter * * @brief Set a Simple Profile parameter. * * @param param - Profile parameter ID * @param len - length of data to right * @param value - pointer to data to write. This is dependent on * the parameter ID and WILL be cast to the appropriate * data type (example: data type of uint16 will be cast to * uint16 pointer). * * @return bStatus_t */ bStatus_t SimpleProfile_SetParameter( uint8 param, uint8 len, void *value ) { bStatus_t ret = SUCCESS; switch ( param ) { case SIMPLEPROFILE_CHAR1: if ( len == sizeof ( uint8 ) ) { simpleProfileChar1 = *((uint8*)value); } else { ret = bleInvalidRange; } break; case SIMPLEPROFILE_CHAR2: if ( len == sizeof ( uint8 ) ) { simpleProfileChar2 = *((uint8*)value); } else { ret = bleInvalidRange; } break; case SIMPLEPROFILE_CHAR3: if ( len == sizeof ( uint8 ) ) { simpleProfileChar3 = *((uint8*)value); } else { ret = bleInvalidRange; } break; case SIMPLEPROFILE_CHAR4: if ( len == sizeof ( uint8 ) ) { simpleProfileChar4 = *((uint8*)value); // See if Notification has been enabled GATTServApp_ProcessCharCfg( simpleProfileChar4Config, &simpleProfileChar4, FALSE, simpleProfileAttrTbl, GATT_NUM_ATTRS( simpleProfileAttrTbl ), INVALID_TASK_ID ); } else { ret = bleInvalidRange; } break; case SIMPLEPROFILE_CHAR5: ret = bleInvalidRange; break; case SIMPLEPROFILE_CHAR6: //LCD_WRITE_STRING_VALUE( "SetParameter 6 len=", len, 10, HAL_LCD_LINE_1 ); //if ( len == SIMPLEPROFILE_CHAR6_LEN ) if ( len <= SIMPLEPROFILE_CHAR6_LEN ) { VOID osal_memcpy( simpleProfileChar6, value, len ); simpleProfileChar6Len = len; // See if Notification has been enabled GATTServApp_ProcessCharCfg( simpleProfileChar6Config, simpleProfileChar6, FALSE, simpleProfileAttrTbl, GATT_NUM_ATTRS( simpleProfileAttrTbl ), INVALID_TASK_ID ); } else { ret = bleInvalidRange; } break; case SIMPLEPROFILE_CHAR7: case SIMPLEPROFILE_CHAR8: case SIMPLEPROFILE_CHAR9: case SIMPLEPROFILE_CHARA: ret = bleInvalidRange; break; default: ret = INVALIDPARAMETER; break; } return ( ret ); }
/************************************************************************************************** * @fn HalLcdWriteString * * @brief Write a string to the LCD * * @param str - pointer to the string that will be displayed * option - display options * * @return None **************************************************************************************************/ void HalLcdWriteString ( char *str, uint8 option) { #if (HAL_LCD == TRUE) uint8 strLen = 0; uint8 totalLen = 0; uint8 *buf; uint8 tmpLen; if ( Lcd_Line1 == NULL ) { Lcd_Line1 = osal_mem_alloc( HAL_LCD_MAX_CHARS+1 ); HalLcdWriteString( "TexasInstruments", 1 ); } strLen = (uint8)osal_strlen( (char*)str ); /* Check boundries */ if ( strLen > HAL_LCD_MAX_CHARS ) strLen = HAL_LCD_MAX_CHARS; if ( option == HAL_LCD_LINE_1 ) { /* Line 1 gets saved for later */ osal_memcpy( Lcd_Line1, str, strLen ); Lcd_Line1[strLen] = '\0'; } else { /* Line 2 triggers action */ tmpLen = (uint8)osal_strlen( (char*)Lcd_Line1 ); totalLen = tmpLen + 1 + strLen + 1; buf = osal_mem_alloc( totalLen ); if ( buf != NULL ) { /* Concatenate strings */ osal_memcpy( buf, Lcd_Line1, tmpLen ); buf[tmpLen++] = ' '; osal_memcpy( &buf[tmpLen], str, strLen ); buf[tmpLen+strLen] = '\0'; /* Send it out */ #if defined (ZTOOL_P1) || defined (ZTOOL_P2) #if defined(SERIAL_DEBUG_SUPPORTED) debug_str( (uint8*)buf ); #endif //LCD_SUPPORTED #endif //ZTOOL_P1 /* Free mem */ osal_mem_free( buf ); } } /* Display the string */ HalLcd_HW_WriteLine (option, str); #endif //HAL_LCD }
/********************************************************************* * @fn simpleProfile_ReadAttrCB * * @brief Read an attribute. * * @param connHandle - connection message was received on * @param pAttr - pointer to attribute * @param pValue - pointer to data to be read * @param pLen - length of data to be read * @param offset - offset of the first octet to be read * @param maxLen - maximum length of data to be read * * @return Success or Failure */ static uint8 simpleProfile_ReadAttrCB( uint16 connHandle, gattAttribute_t *pAttr, uint8 *pValue, uint8 *pLen, uint16 offset, uint8 maxLen ) { bStatus_t status = SUCCESS; // If attribute permissions require authorization to read, return error if ( gattPermitAuthorRead( pAttr->permissions ) ) { // Insufficient authorization return ( ATT_ERR_INSUFFICIENT_AUTHOR ); } // Make sure it's not a blob operation (no attributes in the profile are long) if ( offset > 0 ) { return ( ATT_ERR_ATTR_NOT_LONG ); } if ( pAttr->type.len == ATT_BT_UUID_SIZE ) { // 16-bit UUID uint16 uuid = BUILD_UINT16( pAttr->type.uuid[0], pAttr->type.uuid[1]); switch ( uuid ) { // No need for "GATT_SERVICE_UUID" or "GATT_CLIENT_CHAR_CFG_UUID" cases; // gattserverapp handles those reads // characteristics 1 and 2 have read permissions // characteritisc 3 does not have read permissions; therefore it is not // included here // characteristic 4 does not have read permissions, but because it // can be sent as a notification, it is included here case SIMPLEPROFILE_CHAR1_UUID: case SIMPLEPROFILE_CHAR2_UUID: case SIMPLEPROFILE_CHAR4_UUID: *pLen = 1; pValue[0] = *pAttr->pValue; break; case SIMPLEPROFILE_CHAR6_UUID: /* //*Len = SIMPLEPROFILE_CHAR6_LEN; //VOID osal_memcpy( pValue, pAttr->pValue, SIMPLEPROFILE_CHAR6_LEN ); //LCD_WRITE_STRING_VALUE( "ReadAttrCB 6 len=", simpleProfileChar6Len, 10, HAL_LCD_LINE_1 ); *pLen = simpleProfileChar6Len; VOID osal_memcpy( pValue, pAttr->pValue, simpleProfileChar6Len ); { // 这个变量用于表明上一次写数据到从机已经成功, 可用于判断写数据时的判断, 以确保数据的完整性 //extern bool simpleBLEChar6DoWrite2; //simpleBLEChar6DoWrite2 = TRUE; } break; */ case SIMPLEPROFILE_CHAR5_UUID: case SIMPLEPROFILE_CHAR7_UUID: case SIMPLEPROFILE_CHAR8_UUID: case SIMPLEPROFILE_CHAR9_UUID: case SIMPLEPROFILE_CHARA_UUID: { uint8 newValue[20]; extern uint8 simpleProfileReadConfig(uint16 uuid, uint8 *newValue); *pLen = simpleProfileReadConfig(uuid, newValue); VOID osal_memcpy( pValue, newValue, *pLen ); } break; default: // Should never get here! (characteristics 3 and 4 do not have read permissions) *pLen = 0; status = ATT_ERR_ATTR_NOT_FOUND; break; } } else { // 128-bit UUID *pLen = 0; status = ATT_ERR_INVALID_HANDLE; } return ( status ); }
//INT32 WMT_ioctl(struct inode *inode, struct file *filp, UINT32 cmd, unsigned long arg) long WMT_unlocked_ioctl ( struct file *filp, unsigned int cmd, unsigned long arg ) { INT32 iRet = 0; WMT_DBG_FUNC("cmd (%u), arg (0x%lx)\n", cmd, arg); switch(cmd) { case 4: /* patch location */ { #if 0 WMT_DBG_FUNC("old patch file: %s \n", pWmtDevCtx->cPatchName); if (copy_from_user(pWmtDevCtx->cPatchName, (void *)arg, OSAL_NAME_MAX)) { iRet = -EFAULT; break; } pWmtDevCtx->cPatchName[OSAL_NAME_MAX] = '\0'; WMT_DBG_FUNC("new patch file name: %s \n", pWmtDevCtx->cPatchName); #endif UCHAR cPatchName[OSAL_NAME_MAX + 1]; if (copy_from_user(cPatchName, (void *)arg, OSAL_NAME_MAX)) { iRet = -EFAULT; break; } cPatchName[OSAL_NAME_MAX] = '\0'; wmt_lib_set_patch_name(cPatchName); } break; case 5: /* stp/hif/fm mode */ /* set hif conf */ do { P_OSAL_OP pOp; MTK_WCN_BOOL bRet; P_OSAL_SIGNAL pSignal = NULL; P_WMT_HIF_CONF pHif = NULL; iRet = wmt_lib_set_hif(arg); if (0 != iRet) { WMT_INFO_FUNC("wmt_lib_set_hif fail\n"); break; } pOp = wmt_lib_get_free_op(); if (!pOp) { WMT_INFO_FUNC("get_free_lxop fail\n"); break; } pSignal = &pOp->signal; pOp->op.opId = WMT_OPID_HIF_CONF; pHif = wmt_lib_get_hif(); osal_memcpy(&pOp->op.au4OpData[0], pHif, sizeof(WMT_HIF_CONF)); pOp->op.u4InfoBit = WMT_OP_HIF_BIT; pSignal->timeoutValue = 0; bRet = wmt_lib_put_act_op(pOp); WMT_DBG_FUNC("WMT_OPID_HIF_CONF result(%d) \n", bRet); iRet = (MTK_WCN_BOOL_FALSE == bRet) ? -EFAULT : 0; } while (0); break; case 6: /* test turn on/off func */ do { MTK_WCN_BOOL bRet = MTK_WCN_BOOL_FALSE; if (arg & 0x80000000) { bRet = mtk_wcn_wmt_func_on(arg & 0xF); } else { bRet = mtk_wcn_wmt_func_off(arg & 0xF); } iRet = (MTK_WCN_BOOL_FALSE == bRet) ? -EFAULT : 0; } while (0); break; case 7: /*switch Loopback function on/off arg: bit0 = 1:turn loopback function on bit0 = 0:turn loopback function off */ do{ MTK_WCN_BOOL bRet = MTK_WCN_BOOL_FALSE; if (arg & 0x01) { bRet = mtk_wcn_wmt_func_on(WMTDRV_TYPE_LPBK); } else { bRet = mtk_wcn_wmt_func_off(WMTDRV_TYPE_LPBK); } iRet = (MTK_WCN_BOOL_FALSE == bRet) ? -EFAULT : 0; }while(0); break; case 8: do { P_OSAL_OP pOp; MTK_WCN_BOOL bRet; UINT32 u4Wait; //UINT8 lpbk_buf[1024] = {0}; UINT32 effectiveLen = 0; P_OSAL_SIGNAL pSignal = NULL; if (copy_from_user(&effectiveLen, (void *)arg, sizeof(effectiveLen))) { iRet = -EFAULT; WMT_ERR_FUNC("copy_from_user failed at %d\n", __LINE__); break; } if (effectiveLen > sizeof(gLpbkBuf)) { iRet = -EFAULT; WMT_ERR_FUNC("length is too long\n"); break; } WMT_DBG_FUNC("len = %d\n", effectiveLen); pOp = wmt_lib_get_free_op(); if (!pOp) { WMT_WARN_FUNC("get_free_lxop fail \n"); iRet = -EFAULT; break; } u4Wait = 2000; if (copy_from_user(&gLpbkBuf[0], (void *)arg + sizeof(unsigned long), effectiveLen)) { WMT_ERR_FUNC("copy_from_user failed at %d\n", __LINE__); iRet = -EFAULT; break; } pSignal = &pOp->signal; pOp->op.opId = WMT_OPID_LPBK; pOp->op.au4OpData[0] = effectiveLen; //packet length pOp->op.au4OpData[1] = (UINT32)&gLpbkBuf[0]; //packet buffer pointer memcpy(&gLpbkBufLog, &gLpbkBuf[((effectiveLen >=4) ? effectiveLen-4:0)], 4); pSignal->timeoutValue = MAX_EACH_WMT_CMD; WMT_DBG_FUNC("OPID(%d)type(%d)start\n", pOp->op.opId, pOp->op.au4OpData[0]); wmt_lib_disable_psm_monitor(); bRet = wmt_lib_put_act_op(pOp); wmt_lib_enable_psm_monitor(); if (MTK_WCN_BOOL_FALSE == bRet) { WMT_WARN_FUNC("OPID(%d) type(%d) buf tail(0x%08x) fail\n", pOp->op.opId, pOp->op.au4OpData[0], gLpbkBufLog); iRet = -1; break; } else { WMT_DBG_FUNC("OPID(%d)length(%d) ok\n", pOp->op.opId, pOp->op.au4OpData[0]); iRet = pOp->op.au4OpData[0] ; if (copy_to_user((void *)arg + sizeof(ULONG) + sizeof(UCHAR[2048]), gLpbkBuf, iRet)) { iRet = -EFAULT; break; } } }while(0); break; #if 0 case 9: { #define LOG_BUF_SZ 300 UCHAR buf[LOG_BUF_SZ]; INT32 len = 0; INT32 remaining = 0; remaining = mtk_wcn_stp_btm_get_dmp(buf, &len); if (remaining == 0){ WMT_DBG_FUNC("waiting dmp \n"); wait_event_interruptible(dmp_wq, dmp_flag != 0); dmp_flag = 0; remaining = mtk_wcn_stp_btm_get_dmp(buf, &len); //WMT_INFO_FUNC("len = %d ###%s#\n", len, buf); } else { WMT_LOUD_FUNC("no waiting dmp \n"); } if (unlikely((len+sizeof(INT32)) >= LOG_BUF_SZ)){ WMT_ERR_FUNC("len is larger buffer\n"); iRet = -EFAULT; goto fail_exit; } buf[sizeof(INT32)+len]='\0'; if (copy_to_user((void *)arg, (UCHAR *)&len, sizeof(INT32))){ iRet = -EFAULT; goto fail_exit; } if (copy_to_user((void *)arg + sizeof(INT32), buf, len)){ iRet = -EFAULT; goto fail_exit; } } break; case 10: { WMT_INFO_FUNC("Enable combo trace32 dump\n"); wmt_cdev_t32dmp_enable(); WMT_INFO_FUNC("Enable STP debugging mode\n"); mtk_wcn_stp_dbg_enable(); } break; case 11: { WMT_INFO_FUNC("Disable combo trace32 dump\n"); wmt_cdev_t32dmp_disable(); WMT_INFO_FUNC("Disable STP debugging mode\n"); mtk_wcn_stp_dbg_disable(); } break; #endif case 12: { if (0 == arg) { return wmt_lib_get_icinfo(WMTCHIN_CHIPID); } else if (1 == arg) { return wmt_lib_get_icinfo(WMTCHIN_HWVER); } else if (2 == arg) { return wmt_lib_get_icinfo(WMTCHIN_FWVER); } } break; #if 1 //#ifdef MTK_MULTI_PATCH_SUPPORT case 14: { pAtchNum = arg; WMT_INFO_FUNC(" get patch num from launcher = %d\n",pAtchNum); wmt_lib_set_patch_num(pAtchNum); pPatchInfo = kzalloc(sizeof(WMT_PATCH_INFO)*pAtchNum,GFP_ATOMIC); if(!pPatchInfo) { WMT_ERR_FUNC("allocate memory fail!\n"); break; } } break; case 15: { WMT_PATCH_INFO wMtPatchInfo; P_WMT_PATCH_INFO pTemp = NULL; UINT32 dWloadSeq; static UINT32 counter = 0; if(!pPatchInfo) { WMT_ERR_FUNC("NULL patch info pointer\n"); break; } if (copy_from_user(&wMtPatchInfo, (void *)arg, sizeof(WMT_PATCH_INFO))) { WMT_ERR_FUNC("copy_from_user failed at %d\n", __LINE__); iRet = -EFAULT; break; } dWloadSeq = wMtPatchInfo.dowloadSeq; WMT_DBG_FUNC("current download seq no is %d,patch name is %s,addres info is 0x%02x,0x%02x,0x%02x,0x%02x\n",dWloadSeq,wMtPatchInfo.patchName,wMtPatchInfo.addRess[0],wMtPatchInfo.addRess[1],wMtPatchInfo.addRess[2],wMtPatchInfo.addRess[3]); osal_memcpy(pPatchInfo + dWloadSeq - 1,&wMtPatchInfo,sizeof(WMT_PATCH_INFO)); pTemp = pPatchInfo + dWloadSeq - 1; if(++counter == pAtchNum) { wmt_lib_set_patch_info(pPatchInfo); counter = 0; } } break; #endif default: iRet = -EINVAL; WMT_WARN_FUNC("unknown cmd (%d)\n", cmd); break; } return iRet; }
/********************************************************************* * @fn SampleApp_Init * @brief Initialization function for the Generic App Task. * This is called during initialization and should contain * any application specific initialization (ie. hardware * initialization/setup, table initialization, power up * notificaiton ... ). * @param task_id - the ID assigned by OSAL. This ID should be * used to send messages and set timers. * @return none */ void SampleApp_Init( uint8 task_id ) { SampleApp_TaskID = task_id; SampleApp_NwkState = DEV_INIT; SampleApp_TransID = 0; //initial uart1 and uart0 initUart1(UART_callback); MT_UartInit();//初始化 // Device hardware initialization can be added here or in main() (Zmain.c). // If the hardware is application specific - add it here. // If the hardware is other parts of the device add it in main(). #if defined ( BUILD_ALL_DEVICES ) // The "Demo" target is setup to have BUILD_ALL_DEVICES and HOLD_AUTO_START // We are looking at a jumper (defined in SampleAppHw.c) to be jumpered // together - if they are - we will start up a coordinator. Otherwise, // the device will start as a router. if ( readCoordinatorJumper() ) zgDeviceLogicalType = ZG_DEVICETYPE_COORDINATOR; else zgDeviceLogicalType = ZG_DEVICETYPE_ROUTER; #endif // BUILD_ALL_DEVICES #if defined ( HOLD_AUTO_START ) // HOLD_AUTO_START is a compile option that will surpress ZDApp // from starting the device and wait for the application to // start the device. ZDOInitDevice(0); #endif // Setup for the periodic message's destination address // Broadcast to everyone SampleApp_Periodic_DstAddr.addrMode = (afAddrMode_t)AddrBroadcast; SampleApp_Periodic_DstAddr.endPoint = SAMPLEAPP_ENDPOINT; SampleApp_Periodic_DstAddr.addr.shortAddr = 0xFFFF; // Setup for the flash command's destination address - Group 1 SampleApp_Flash_DstAddr.addrMode = (afAddrMode_t)afAddrGroup; SampleApp_Flash_DstAddr.endPoint = SAMPLEAPP_ENDPOINT; SampleApp_Flash_DstAddr.addr.shortAddr = SAMPLEAPP_FLASH_GROUP; // 点对点通讯定义 Point_To_Point_DstAddr.addrMode = (afAddrMode_t)Addr16Bit; //点播 Point_To_Point_DstAddr.endPoint = SAMPLEAPP_ENDPOINT; Point_To_Point_DstAddr.addr.shortAddr = 0x0000;//发给协调器 // Fill out the endpoint description. SampleApp_epDesc.endPoint = SAMPLEAPP_ENDPOINT; SampleApp_epDesc.task_id = &SampleApp_TaskID; SampleApp_epDesc.simpleDesc = (SimpleDescriptionFormat_t *)&SampleApp_SimpleDesc; SampleApp_epDesc.latencyReq = noLatencyReqs; // Register the endpoint description with the AF afRegister( &SampleApp_epDesc ); // Register for all key events - This app will handle all key events RegisterForKeys( SampleApp_TaskID ); // By default, all devices start out in Group 1 SampleApp_Group.ID = 0x0001; osal_memcpy( SampleApp_Group.name, "Group 1", 7 ); aps_AddGroup( SAMPLEAPP_ENDPOINT, &SampleApp_Group ); }
/* wcn_core_dump_in - add a packet to compressor buffer * @ dmp - pointer of object * @ buf - input buffer * @ len - data length * * Retunr 0 if success; return 1 if find end string; else error code */ INT32 wcn_core_dump_in(P_WCN_CORE_DUMP_T dmp, PUINT8 buf, INT32 len) { INT32 ret = 0; INT32 tmp; #define INFO_HEAD "MT6628 FW CORE, " if ((!dmp) || (!buf)) { STP_DBG_ERR_FUNC("invalid pointer!\n"); return -1; } ret = osal_lock_sleepable_lock(&dmp->dmp_lock); if (ret) { STP_DBG_ERR_FUNC("--->lock dmp->dmp_lock failed, ret=%d\n", ret); return ret; } switch (dmp->sm) { case CORE_DUMP_INIT: wcn_compressor_reset(dmp->compressor, 1, GZIP); osal_timer_start(&dmp->dmp_timer, STP_CORE_DUMP_TIMEOUT); // first package, copy to info buffer osal_strcpy(&dmp->info[0], INFO_HEAD); tmp = STP_CORE_DUMP_INFO_SZ - osal_strlen(INFO_HEAD); tmp = (len > tmp) ? tmp : len; osal_memcpy(&dmp->info[osal_strlen(INFO_HEAD)], buf, tmp); dmp->info[STP_CORE_DUMP_INFO_SZ] = '\0'; // show coredump start info on UI //osal_dbg_assert_aee("MT662x f/w coredump start", "MT662x firmware coredump start"); #if WMT_PLAT_ALPS aee_kernel_dal_show("MT662x coredump start, please wait up to 5 minutes.\n"); #endif // parsing data, and check end srting ret = wcn_core_dump_check_end(buf, len); if (ret == 1) { STP_DBG_INFO_FUNC("core dump end!\n"); dmp->sm = CORE_DUMP_DONE; wcn_compressor_in(dmp->compressor, buf, len, 1); } else { dmp->sm = CORE_DUMP_DOING; wcn_compressor_in(dmp->compressor, buf, len, 0); } break; case CORE_DUMP_DOING: // parsing data, and check end srting ret = wcn_core_dump_check_end(buf, len); if (ret == 1) { STP_DBG_INFO_FUNC("core dump end!\n"); dmp->sm = CORE_DUMP_DONE; wcn_compressor_in(dmp->compressor, buf, len, 1); } else { dmp->sm = CORE_DUMP_DOING; wcn_compressor_in(dmp->compressor, buf, len, 0); } break; case CORE_DUMP_DONE: wcn_compressor_reset(dmp->compressor, 1, GZIP); osal_timer_start(&dmp->dmp_timer, STP_CORE_DUMP_TIMEOUT); wcn_compressor_in(dmp->compressor, buf, len, 0); dmp->sm = CORE_DUMP_DOING; break; case CORE_DUMP_TIMEOUT: break; default: break; } osal_unlock_sleepable_lock(&dmp->dmp_lock); return ret; }