/***************************************************************************** * FUNCTION: WFProcess * * RETURNS: None * * PARAMS: None * * NOTES: This function is called from WFProcess. It does the following: * 1) checks for and processes MRF24W external interrupt events * 2) checks for and processes received management messages from the MRF24W * 3) maintains the PS-Poll state (if applicable) * *****************************************************************************/ void WFProcess(void) { #if defined(__18CXX) static UINT16 len; #else UINT16 len; #endif //---------------------------------------------------------- // if there is a MRF24W External interrupt (EINT) to process //---------------------------------------------------------- if (g_ExIntNeedsServicing == TRUE) { g_ExIntNeedsServicing = FALSE; ProcessInterruptServiceResult(); } //---------------------------------------- // else if there is management msg to read //---------------------------------------- else if (g_MgmtReadMsgReady == TRUE) { RawGetMgmtRxBuffer(&len); // handle received managment message g_MgmtReadMsgReady = FALSE; ProcessMgmtRxMsg(); // reenable interrupts WF_EintEnable(); } }
/***************************************************************************** * FUNCTION: WFProcess * * RETURNS: None * * PARAMS: None * * NOTES: This function is called from WFProcess. It does the following: * 1) checks for and processes MRF24WB0M external interrupt events * 2) checks for and processes received management messages from the MRF24WB0M * 3) maintains the PS-Poll state (if applicable) * *****************************************************************************/ void WFProcess(void) { UINT16 len; //---------------------------------------------------------- // if there is a MRF24WB0M External interrupt (EINT) to process //---------------------------------------------------------- if (g_ExIntNeedsServicing == TRUE) { g_ExIntNeedsServicing = FALSE; ProcessInterruptServiceResult(); } //---------------------------------------- // else if there is management msg to read //---------------------------------------- else if (g_MgmtReadMsgReady == TRUE) { /* Ensure the MRF24WB0M is awake (only applies if PS-Poll was enabled) */ EnsureWFisAwake(); //----------------------------- // process management read //----------------------------- // if the Raw Rx buffer is available, or only has the scratch mounted, then mount it so // we can process received Mgmt message. Otherwise, stay in this state and keep checking // until we can mount the Raw Rx buffer and get the management message. Once the Raw Rx // is acquired, rx data packets are held off until we finish processing mgmt message. if ( RawGetMgmtRxBuffer(&len) ) { // handle received managment message g_MgmtReadMsgReady = FALSE; ProcessMgmtRxMsg(); // reenable interrupts WF_EintEnable(); } } //----------------------------------- // else no EINT or Mgmt Rx to process //----------------------------------- else { #if defined (WF_USE_POWER_SAVE_FUNCTIONS) /* if PS-Poll mode was enabled by application and was previously deactivated by WF driver */ if (WFisPsPollEnabled() && !WFIsPsPollActive() ) { /* reactivate PS-Poll mode on MRF24WB0M (allow MRF24WB0M to sleep) */ WFConfigureLowPowerMode(WF_LOW_POWER_MODE_ON); } #endif } }
/***************************************************************************** * FUNCTION: WFProcess * * RETURNS: None * * PARAMS: None * * NOTES: This function is called from WFProcess. It does the following: * 1) checks for and processes MRF24W external interrupt events * 2) checks for and processes received management messages from the MRF24W * 3) maintains the PS-Poll state (if applicable) * *****************************************************************************/ void WFProcess(void) { #if defined(__XC8) static uint16_t len; #else uint16_t len; #endif //---------------------------------------------------------- // if there is a MRF24W External interrupt (EINT) to process //---------------------------------------------------------- if (g_ExIntNeedsServicing == true) { g_ExIntNeedsServicing = false; ProcessInterruptServiceResult(); } //---------------------------------------- // else if there is management msg to read //---------------------------------------- else if (g_MgmtReadMsgReady == true) { //----------------------------- // process management read //----------------------------- // if the Raw Rx buffer is available, or only has the scratch mounted, then mount it so // we can process received Mgmt message. Otherwise, stay in this state and keep checking // until we can mount the Raw Rx buffer and get the management message. Once the Raw Rx // is acquired, rx data packets are held off until we finish processing mgmt message. if ( RawGetMgmtRxBuffer(&len) ) { // handle received managment message g_MgmtReadMsgReady = false; ProcessMgmtRxMsg(); // reenable interrupts WF_EintEnable(); } } }
/***************************************************************************** * FUNCTION: WFProcess * * RETURNS: None * * PARAMS: None * * NOTES: This function is called from WFProcess. It does the following: * 1) checks for and processes MRF24WB0M external interrupt events * 2) checks for and processes received management messages from the MRF24WB0M * 3) maintains the PS-Poll state (if applicable) * *****************************************************************************/ void WFProcess(void) { UINT16 len; //---------------------------------------------------------- // if there is a MRF24WB0M External interrupt (EINT) to process //---------------------------------------------------------- if (g_ExIntNeedsServicing == TRUE) { g_ExIntNeedsServicing = FALSE; ProcessInterruptServiceResult(); } //---------------------------------------- // else if there is management msg to read //---------------------------------------- else if (g_MgmtReadMsgReady == TRUE) { /* Ensure the MRF24WB0M is awake (only applies if PS-Poll was enabled) */ EnsureWFisAwake(); //----------------------------- // process management read //----------------------------- // if the Raw Rx buffer is available, or only has the scratch mounted, then mount it so // we can process received Mgmt message. Otherwise, stay in this state and keep checking // until we can mount the Raw Rx buffer and get the management message. Once the Raw Rx // is acquired, rx data packets are held off until we finish processing mgmt message. if ( RawGetMgmtRxBuffer(&len) ) { // handle received managment message g_MgmtReadMsgReady = FALSE; ProcessMgmtRxMsg(); // reenable interrupts WF_EintEnable(); } } }
/***************************************************************************** * FUNCTION: ZGPrvComStateMachine * * RETURNS: N/A * * PARAMS: * N/A * * * NOTES: Represents the State machine for the COM layer of the ZG Driver. * The responsibility of the COM layer is to schedule SPI operations * and act as a receiver of interrupt notifications from the G2100. * Essentially read and write fifo operations are submitted from the * MAC layer 1 at a time and separately an interrupt can be received * from the G2100 the meaning of which needs to be determined. The * State machine initially starts in the idle state and waits for one * of these 2 events with priority going to the interrupt event however * once an operation is started in cannot be pre-empted. Interrupt * processing requires reading and writing several chip registers to * learn the meaning of the interrupt and clear the interrupt. With * the results being routed to the MAC layer for further processing. * Fifo operation is either a read or write operation which involves * several SPI steps that must be scheduled *****************************************************************************/ tZGVoidReturn ZGPrvComStateMachine(tZGVoidInput) { tZGU8 bLoop = 0; tZGU16 len; tZGBool res; do { if(COMCXT.state == kComStIdle) { //----------------------------------------- // if there is an EINT interrupt to process //----------------------------------------- if(COMCXT.bIntServiceReq == kZGBoolTrue) { COMCXT.bIntServiceReq = kZGBoolFalse; COMCXT.state = kComStIntService; } //-------------------------------------------- // if there is management msg to read or write //-------------------------------------------- else if(COMCXT.bRdWtReady == kZGBoolTrue) { /* if the chip is in low power mode then it must first be * brought out of low power before attempting a write * operation. */ if(COMCXT.bLowPowerModeActive) { ChangeLowPowerMode(kZGBoolFalse); } COMCXT.state = (RWCXT.dir == kZGDirWrite)? kComStWriteOperation : kComStReadOperation; //---------------------------- // if doing a management write //---------------------------- if (RWCXT.dir == kZGDirWrite) { res = ZGSendRAWManagementFrame(RWCXT.len); if (res == kZGBoolFalse) { ZGErrorHandler((ROM char *)"Mgmt Send Failed"); } COMCXT.bRdWtReady = kZGBoolFalse; ZGPrvMacOpComplete(); COMCXT.state = kComStIdle; } //----------------------------- // else doing a management read //----------------------------- else { // if the Raw Rx buffer is available, or only has the scratch mounted, then mount it so // we can process received Mgmt message. Otherwise, stay in this state and keep checking // until we can mount the Raw Rx buffer and get the management message. Once the Raw Rx // is acquired, rx data packets are held off until we finish processing mgmt message. if ( ZGRawGetMgmtRxBuffer(&len) ) { // handle received managment message COMCXT.bRdWtReady = kZGBoolFalse; ZGPrvMacOpComplete(); COMCXT.state = kComStIdle; // reenable interrupts zgHALEintEnable(); } } } //------------------------------------------------------------- // else no manangement tx or rx to do, so check for other stuff //------------------------------------------------------------- else { bLoop = 0; /* manage low power control of g2100 */ if(COMCXT.bLowPowerModeDesired == kZGBoolTrue && COMCXT.bLowPowerModeActive == kZGBoolFalse && MACCXT.bMgmtTxMsgReady == kZGBoolTrue) { ChangeLowPowerMode(kZGBoolTrue); } } } //-------------------------- // else COMCXT.state != IDLE //-------------------------- else { bLoop = 1; switch(COMCXT.state) { case kComStIntService: /* use spi to determine device interrupt reason */ ProcessInterruptServiceResult(); break; case kComStReadOperation: /* spi fifo read operation in progress */ COMCXT.state = kComStReadWaitFifoDone; ZGPrvMacOpComplete(); break; case kComStWriteOperation: /* spi fifo write operation in progress */ COMCXT.state = kComStWriteWaitFifoDone; ZGPrvMacOpComplete(); break; case kComStReadWaitFifoDone: COMCXT.state = kComStIdle; break; case kComStWriteWaitFifoDone: /* complete the fifo operation */ COMCXT.state = kComStIdle; break; } } } while(bLoop); }