* @author Jonathan Hui <jhui@archrock.com>
* @author David Moss
* @author Jung Il Choi Initial SACK implementation
+ * @author JeongGil Ko
+ * @author Razvan Musaloiu-E
* @version $Revision$ $Date$
*/
uses interface CC2420Strobe as SFLUSHTX;
uses interface CC2420Register as MDMCTRL1;
+ uses interface CC2420Strobe as STXENC;
+ uses interface CC2420Register as SECCTRL0;
+ uses interface CC2420Register as SECCTRL1;
+ uses interface CC2420Ram as KEY0;
+ uses interface CC2420Ram as KEY1;
+ uses interface CC2420Ram as TXNONCE;
+
uses interface CC2420Receive;
uses interface Leds;
}
enum {
CC2420_ABORT_PERIOD = 320
};
+
+#ifdef CC2420_HW_SECURITY
+ uint16_t startTime = 0;
+ norace uint8_t secCtrlMode = 0;
+ norace uint8_t nonceValue[16] = {0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01};
+ norace uint8_t skip;
+ norace uint16_t CTR_SECCTRL0, CTR_SECCTRL1;
+ uint8_t securityChecked = 0;
+
+ void securityCheck();
+#endif
norace message_t * ONE_NOK m_msg;
norace uint8_t m_tx_power;
cc2420_transmit_state_t m_state = S_STOPPED;
-
+
bool m_receiving = FALSE;
uint16_t m_prev_time;
if ( type == IEEE154_TYPE_ACK && m_msg) {
ack_header = call CC2420PacketBody.getHeader( ack_msg );
msg_header = call CC2420PacketBody.getHeader( m_msg );
-
if ( m_state == S_ACK_WAIT && msg_header->dsn == ack_header->dsn ) {
call BackoffTimer.stop();
return FAIL;
}
+#ifdef CC2420_HW_SECURITY
+ securityChecked = 0;
+#endif
m_state = S_LOAD;
m_cca = cca;
m_msg = p_msg;
return SUCCESS;
}
-
+#ifdef CC2420_HW_SECURITY
+
+ task void waitTask(){
+ call Leds.led2Toggle();
+ if(SECURITYLOCK == 1){
+ post waitTask();
+ }else{
+ securityCheck();
+ }
+ }
+
+ void securityCheck(){
+
+ cc2420_header_t* msg_header;
+ cc2420_status_t status;
+ security_header_t* secHdr;
+ uint8_t mode;
+ uint8_t key;
+ uint8_t micLength;
+
+ msg_header = call CC2420PacketBody.getHeader( m_msg );
+
+ if(!(msg_header->fcf & (1 << IEEE154_FCF_SECURITY_ENABLED))){
+ // Security is not used for this packet
+ // Make sure to set mode to 0 and the others to the default values
+ CTR_SECCTRL0 = ((0 << CC2420_SECCTRL0_SEC_MODE) |
+ (1 << CC2420_SECCTRL0_SEC_M) |
+ (1 << CC2420_SECCTRL0_SEC_TXKEYSEL) |
+ (1 << CC2420_SECCTRL0_SEC_CBC_HEAD)) ;
+
+ call CSN.clr();
+ call SECCTRL0.write(CTR_SECCTRL0);
+ call CSN.set();
+
+ return;
+ }
+
+ if(SECURITYLOCK == 1){
+ post waitTask();
+ }else {
+ //Will perform encryption lock registers
+ atomic SECURITYLOCK = 1;
+
+ secHdr = (security_header_t*) &msg_header->secHdr;
+ memcpy(&nonceValue[3], &(secHdr->frameCounter), 4);
+
+ skip = secHdr->reserved;
+ key = secHdr->keyID[0]; // For now this is the only key selection mode.
+
+ if (secHdr->secLevel == NO_SEC){
+ mode = CC2420_NO_SEC;
+ micLength = 4;
+ }else if (secHdr->secLevel == CBC_MAC_4){
+ mode = CC2420_CBC_MAC;
+ micLength = 4;
+ }else if (secHdr->secLevel == CBC_MAC_8){
+ mode = CC2420_CBC_MAC;
+ micLength = 8;
+ }else if (secHdr->secLevel == CBC_MAC_16){
+ mode = CC2420_CBC_MAC;
+ micLength = 16;
+ }else if (secHdr->secLevel == CTR){
+ mode = CC2420_CTR;
+ micLength = 4;
+ }else if (secHdr->secLevel == CCM_4){
+ mode = CC2420_CCM;
+ micLength = 4;
+ }else if (secHdr->secLevel == CCM_8){
+ mode = CC2420_CCM;
+ micLength = 8;
+ }else if (secHdr->secLevel == CCM_16){
+ mode = CC2420_CCM;
+ micLength = 16;
+ }else{
+ return;
+ }
+
+ CTR_SECCTRL0 = ((mode << CC2420_SECCTRL0_SEC_MODE) |
+ ((micLength-2)/2 << CC2420_SECCTRL0_SEC_M) |
+ (key << CC2420_SECCTRL0_SEC_TXKEYSEL) |
+ (1 << CC2420_SECCTRL0_SEC_CBC_HEAD)) ;
+#ifndef TFRAMES_ENABLED
+ CTR_SECCTRL1 = (skip+11+sizeof(security_header_t)+((skip+11+sizeof(security_header_t))<<8));
+#else
+ CTR_SECCTRL1 = (skip+10+sizeof(security_header_t)+((skip+10+sizeof(security_header_t))<<8));
+#endif
+
+ call CSN.clr();
+ call SECCTRL0.write(CTR_SECCTRL0);
+ call CSN.set();
+
+ call CSN.clr();
+ call SECCTRL1.write(CTR_SECCTRL1);
+ call CSN.set();
+
+ call CSN.clr();
+ call TXNONCE.write(0, nonceValue, 16);
+ call CSN.set();
+
+ call CSN.clr();
+ status = call SNOP.strobe();
+ call CSN.set();
+
+ while(status & CC2420_STATUS_ENC_BUSY){
+ call CSN.clr();
+ status = call SNOP.strobe();
+ call CSN.set();
+ }
+
+ // Inline security will be activated by STXON or STXONCCA strobes
+
+ atomic SECURITYLOCK = 0;
+
+ }
+ }
+#endif
+
/**
* Attempt to send the packet we have loaded into the tx buffer on
* the radio chip. The STXONCCA will send the packet immediately if
*
* If the packet got sent, we should expect an SFD interrupt to take
* over, signifying the packet is getting sent.
+ *
+ * If security is enabled, STXONCCA or STXON will perform inline security
+ * options before transmitting the packet.
*/
void attemptSend() {
uint8_t status;
signal Send.sendDone( m_msg, ECANCEL );
return;
}
-
-
+#ifdef CC2420_HW_SECURITY
+ if(securityChecked != 1){
+ securityCheck();
+ }
+ securityChecked = 1;
+#endif
call CSN.clr();
-
status = m_cca ? call STXONCCA.strobe() : call STXON.strobe();
if ( !( status & CC2420_STATUS_TX_ACTIVE ) ) {
status = call SNOP.strobe();
congestion = FALSE;
}
}
-
+
m_state = congestion ? S_SAMPLE_CCA : S_SFD;
call CSN.set();
}
-
+
if ( congestion ) {
totalCcaChecks = 0;
releaseSpiResource();
call ChipSpiResource.attemptRelease();
signal Send.sendDone( m_msg, err );
}
+
}
projects / tinyos-2.x.git / blobdiff