eventreg.c

/*
 * eventreg.c - CC31xx/CC32xx Host Driver Implementation
 *
 * Copyright (C) 2017 Texas Instruments Incorporated - https://www.ti.com/ 
 * 
 * 
 *  Redistribution and use in source and binary forms, with or without 
 *  modification, are permitted provided that the following conditions 
 *  are met:
 *
 *    Redistributions of source code must retain the above copyright 
 *    notice, this list of conditions and the following disclaimer.
 *
 *    Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the 
 *    documentation and/or other materials provided with the   
 *    distribution.
 *
 *    Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
 *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
 *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
 *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
 *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
 *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
 *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
 *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
*/

/*****************************************************************************/
/* Include files                                                             */
/*****************************************************************************/
#include <ti/drivers/net/wifi/simplelink.h>
#include <ti/drivers/net/wifi/eventreg.h>


typedef void (*_pSlDeviceFatalErrorEvtHdlr_t)(SlDeviceFatal_t *pSlFatalErrorEvent);
typedef void (*_pSlDeviceGeneralEvtHdlr_t)(SlDeviceEvent_t *pSlDeviceEvent);
typedef void (*_pSlWlanEvtHdlr)(SlWlanEvent_t* pSlWlanEvent);
typedef void (*_pSlNetAppEvtHdlr)(SlNetAppEvent_t* pSlNetAppEvent);
typedef void (*_pSlSockEvtHdlr)(SlSockEvent_t* pSlSockEvent);
typedef void (*_pSlNetAppHttpServerHdlr)(SlNetAppHttpServerEvent_t *pSlHttpServerEvent, SlNetAppHttpServerResponse_t *pSlHttpServerResponse);
typedef void (*_pSlNetAppRequestHdlr)(SlNetAppRequest_t *pNetAppRequest, SlNetAppResponse_t *pNetAppResponse);
typedef void (*_pSlNetAppRequestMemFree)(_u8 *buffer);
typedef void (*_pSlSocketTriggerEventHandler)(SlSockTriggerEvent_t* pSlSockTriggerEvent);


typedef _i32 (*_pSlPropogationDeviceFatalErrorEvtHdlr_t)(SlDeviceFatal_t *pSlFatalErrorEvent);
typedef _i32 (*_pSlPropogationDeviceGeneralEvtHdlr_t)(SlDeviceEvent_t *pSlDeviceEvent);
typedef _i32 (*_pSlPropogationWlanEvtHdlr)(SlWlanEvent_t* pSlWlanEvent);
typedef _i32 (*_pSlPropogationNetAppEvtHdlr)(SlNetAppEvent_t* pSlNetAppEvent);
typedef _i32 (*_pSlPropogationSockEvtHdlr)(SlSockEvent_t* pSlSockEvent);
typedef _i32 (*_pSlPropogationNetAppHttpServerHdlr)(SlNetAppHttpServerEvent_t *pSlHttpServerEvent, SlNetAppHttpServerResponse_t *pSlHttpServerResponse);
typedef _i32 (*_pSlPropogationNetAppRequestHdlr)(SlNetAppRequest_t *pNetAppRequest, SlNetAppResponse_t *pNetAppResponse);
typedef _i32 (*_pSlPropogationNetAppRequestMemFree)(_u8 *buffer);
typedef _i32 (*_pSlPropogationSocketTriggerEventHandler)(SlSockTriggerEvent_t* pSlSockTriggerEvent);

#ifdef SL_RUNTIME_EVENT_REGISTERATION

void* g_UserEvents[SL_NUM_OF_EVENT_TYPES] = {0};
SlEventsListNode_t* g_LibsEvents[SL_NUM_OF_EVENT_TYPES] = {0};

#endif


_i32 _SlIsEventRegistered(SlEventHandler_e EventHandlerType)
{
#ifdef SL_RUNTIME_EVENT_REGISTERATION
    if( (NULL != g_LibsEvents[EventHandlerType]) || (NULL != g_UserEvents[EventHandlerType]) )
    {
        return 1;
    }
#endif
    if(SL_EVENT_HDL_MEM_FREE == EventHandlerType)
    {
#ifdef slcb_NetAppRequestMemFree
        return 1;
#endif
    }
    if(SL_EVENT_HDL_SOCKET_TRIGGER == EventHandlerType)
    {
#ifdef slcb_SocketTriggerEventHandler
        return 1;
#endif
    }

    return 0;
}

#ifdef SL_RUNTIME_EVENT_REGISTERATION

_i32 sl_RegisterEventHandler(SlEventHandler_e EventHandlerType , void* EventHandler)
{
    g_UserEvents[EventHandlerType] = EventHandler;
    return 0;
}

_i32 sl_RegisterLibsEventHandler(SlEventHandler_e EventHandlerType , SlEventsListNode_t* EventHandlerNode)
{
    EventHandlerNode->next = NULL;

    if(g_LibsEvents[EventHandlerType] == NULL)
    {
        g_LibsEvents[EventHandlerType] = EventHandlerNode;
    }
    else
    {
        SlEventsListNode_t* currentNode = g_LibsEvents[EventHandlerType];
        while(currentNode->next != NULL)
        {
            currentNode = currentNode->next;
        }

        currentNode->next = EventHandlerNode;
    }
    return 0;
}

_i32 sl_UnregisterLibsEventHandler(SlEventHandler_e EventHandlerType , SlEventsListNode_t* EventHandlerNode)
{
    SlEventsListNode_t* currentNode = g_LibsEvents[EventHandlerType];
    SlEventsListNode_t* lastNode = g_LibsEvents[EventHandlerType];
    int count = 0;
    while(currentNode != NULL)
    {
        if(EventHandlerNode == currentNode)
        {
            if(count == 0)
            {
                g_LibsEvents[EventHandlerType] = g_LibsEvents[EventHandlerType]->next;
            }
            else
            {
                lastNode->next = currentNode->next;
            }
            return 0;
        }

        if(count != 0)
        {
            lastNode = lastNode->next;
        }
        count++;
        currentNode = currentNode->next;
    }

    return SL_RET_CODE_EVENT_LINK_NOT_FOUND;
}


/* Event handlers section */
void _SlDeviceFatalErrorEvtHdlr(SlDeviceFatal_t *pSlFatalErrorEvent)
{
    SlEventsListNode_t* currentNode = g_LibsEvents[SL_EVENT_HDL_FATAL_ERROR];
    while(currentNode != NULL)
    {
        if(EVENT_PROPAGATION_BLOCK == ((_pSlPropogationDeviceFatalErrorEvtHdlr_t)(currentNode->event))(pSlFatalErrorEvent))
        {
            return;
        }
        currentNode = currentNode->next;
    }

    if (NULL != g_UserEvents[SL_EVENT_HDL_FATAL_ERROR])
    {
        ((_pSlDeviceFatalErrorEvtHdlr_t)g_UserEvents[SL_EVENT_HDL_FATAL_ERROR])(pSlFatalErrorEvent);
    }

#ifdef slcb_DeviceFatalErrorEvtHdlr
    else
    {
        slcb_DeviceFatalErrorEvtHdlr(pSlFatalErrorEvent);
    }
#endif
}


void _SlDeviceGeneralEvtHdlr(SlDeviceEvent_t *pSlDeviceEvent)
{
    SlEventsListNode_t* currentNode = g_LibsEvents[SL_EVENT_HDL_DEVICE_GENERAL];
    while(currentNode != NULL)
    {
        if(EVENT_PROPAGATION_BLOCK == ((_pSlPropogationDeviceGeneralEvtHdlr_t)(currentNode->event))(pSlDeviceEvent))
        {
            return;
        }
        currentNode = currentNode->next;
    }

    if (NULL != g_UserEvents[SL_EVENT_HDL_DEVICE_GENERAL])
    {
        ((_pSlDeviceGeneralEvtHdlr_t)g_UserEvents[SL_EVENT_HDL_DEVICE_GENERAL])(pSlDeviceEvent);
    }
#ifdef slcb_DeviceGeneralEvtHdlr
    else
    {
        slcb_DeviceGeneralEvtHdlr(pSlDeviceEvent);
    }
#endif
}


void _SlWlanEvtHdlr(SlWlanEvent_t* pSlWlanEvent)
{
    SlEventsListNode_t* currentNode = g_LibsEvents[SL_EVENT_HDL_WLAN];
    while(currentNode != NULL)
    {
        if(EVENT_PROPAGATION_BLOCK == ((_pSlPropogationWlanEvtHdlr)(currentNode->event))(pSlWlanEvent))
        {
            return;
        }
        currentNode = currentNode->next;
    }

    if (NULL != g_UserEvents[SL_EVENT_HDL_WLAN])
    {
        ((_pSlWlanEvtHdlr)g_UserEvents[SL_EVENT_HDL_WLAN])(pSlWlanEvent);
    }
#ifdef slcb_WlanEvtHdlr
    else
    {
        slcb_WlanEvtHdlr(pSlWlanEvent);
    }
#endif
}


void _SlNetAppEvtHdlr(SlNetAppEvent_t* pSlNetAppEvent)
{
    SlEventsListNode_t* currentNode = g_LibsEvents[SL_EVENT_HDL_NETAPP];
    while(currentNode != NULL)
    {
        if(EVENT_PROPAGATION_BLOCK == ((_pSlPropogationNetAppEvtHdlr)(currentNode->event))(pSlNetAppEvent))
        {
            return;
        }
        currentNode = currentNode->next;
    }
    if (NULL != g_UserEvents[SL_EVENT_HDL_NETAPP])
    {
        ((_pSlNetAppEvtHdlr)g_UserEvents[SL_EVENT_HDL_NETAPP])(pSlNetAppEvent);
    }
#ifdef slcb_NetAppEvtHdlr
    else
    {
        slcb_NetAppEvtHdlr(pSlNetAppEvent);
    }
#endif
}


void _SlSockEvtHdlr(SlSockEvent_t* pSlSockEvent)
{
    SlEventsListNode_t* currentNode = g_LibsEvents[SL_EVENT_HDL_SOCKET];
    while(currentNode != NULL)
    {
        if(EVENT_PROPAGATION_BLOCK == ((_pSlPropogationSockEvtHdlr)(currentNode->event))(pSlSockEvent))
        {
            return;
        }
        currentNode = currentNode->next;
    }
    if (NULL != g_UserEvents[SL_EVENT_HDL_SOCKET])
    {
        ((_pSlSockEvtHdlr)g_UserEvents[SL_EVENT_HDL_SOCKET])(pSlSockEvent);
    }

#ifdef slcb_SockEvtHdlr
    else
    {
        slcb_SockEvtHdlr(pSlSockEvent);
    }
#endif
}


void _SlNetAppHttpServerHdlr(SlNetAppHttpServerEvent_t *pSlHttpServerEvent, SlNetAppHttpServerResponse_t *pSlHttpServerResponse)
{
    SlEventsListNode_t* currentNode = g_LibsEvents[SL_EVENT_HDL_HTTP_SERVER];
    while(currentNode != NULL)
    {
        if(EVENT_PROPAGATION_BLOCK == ((_pSlPropogationNetAppHttpServerHdlr)(currentNode->event))(pSlHttpServerEvent,pSlHttpServerResponse))
        {
            return;
        }
        currentNode = currentNode->next;
    }
    if (NULL != g_UserEvents[SL_EVENT_HDL_HTTP_SERVER])
    {
        ((_pSlNetAppHttpServerHdlr)g_UserEvents[SL_EVENT_HDL_HTTP_SERVER])(pSlHttpServerEvent,pSlHttpServerResponse);
    }
#ifdef slcb_NetAppHttpServerHdlr
    else
    {
        slcb_NetAppHttpServerHdlr(pSlHttpServerEvent,pSlHttpServerResponse);
    }
#endif
}



void _SlNetAppRequestHdlr(SlNetAppRequest_t *pNetAppRequest, SlNetAppResponse_t *pNetAppResponse)
{
    SlEventsListNode_t* currentNode = g_LibsEvents[SL_EVENT_HDL_NETAPP_REQUEST];
    while(currentNode != NULL)
    {
        if(EVENT_PROPAGATION_BLOCK == ((_pSlPropogationNetAppRequestHdlr)(currentNode->event))(pNetAppRequest,pNetAppResponse))
        {
            return;
        }
        currentNode = currentNode->next;
    }
    if (NULL != g_UserEvents[SL_EVENT_HDL_NETAPP_REQUEST])
    {
        ((_pSlNetAppRequestHdlr)g_UserEvents[SL_EVENT_HDL_NETAPP_REQUEST])(pNetAppRequest,pNetAppResponse);
    }
#ifdef slcb_NetAppRequestHdlr
    else
    {
        slcb_NetAppRequestHdlr(pNetAppRequest,pNetAppResponse);
    }
#endif
}



void _SlNetAppRequestMemFree (_u8 *buffer)
{
    SlEventsListNode_t* currentNode = g_LibsEvents[SL_EVENT_HDL_MEM_FREE];
    while(currentNode != NULL)
    {
        if(EVENT_PROPAGATION_BLOCK == ((_pSlPropogationNetAppRequestMemFree)(currentNode->event))(buffer))
        {
            return;
        }
        currentNode = currentNode->next;
    }
    if (NULL != g_UserEvents[SL_EVENT_HDL_MEM_FREE])
    {
        ((_pSlNetAppRequestMemFree)g_UserEvents[SL_EVENT_HDL_MEM_FREE])(buffer);
    }
#ifdef slcb_NetAppRequestMemFree
    else
    {
        slcb_NetAppRequestMemFree(buffer);
    }
#endif
}


void _SlSocketTriggerEventHandler(SlSockTriggerEvent_t* pSlSockTriggerEvent)
{
    SlEventsListNode_t* currentNode = g_LibsEvents[SL_EVENT_HDL_SOCKET_TRIGGER];
    while(currentNode != NULL)
    {
        if(EVENT_PROPAGATION_BLOCK == ((_pSlPropogationSocketTriggerEventHandler)(currentNode->event))(pSlSockTriggerEvent))
        {
            return;
        }
        currentNode = currentNode->next;
    }
    if (NULL != g_UserEvents[SL_EVENT_HDL_SOCKET_TRIGGER])
    {
        ((_pSlSocketTriggerEventHandler)g_UserEvents[SL_EVENT_HDL_SOCKET_TRIGGER])(pSlSockTriggerEvent);
    }
#ifdef slcb_SocketTriggerEventHandler
    else
    {
        slcb_SocketTriggerEventHandler(pSlSockTriggerEvent);
    }
#endif
}

#endif /* SL_RUNTIME_EVENT_REGISTERATION */