BOOSTXL-CC3120MOD: WiFi SDK: Problem with Non-Blocking sl_Accept()

Hi Kevin, thanks for the reply, sorry for delay, I wasn't in office yesterday.....

The SDK is "simplelink_sdk_wifi_plugin_1_55_00_42". I'm not using any specific example to guide me - I've been following the Porting Guide section of the Programming Manual, together with the comments in the user.h file, etc. I'm then following the function call sequence as documented in the Programming Manual, but I feel that this is quite a low-level problem, nothing to do with the high-level user function calls being wrong.

The semaphore which is correctly released by the first interrupt is NOT the same semaphore as the one which later remains blocked and times out.... but the semaphore that times out IS always the same one, being pended at always the same time after sl_Accept() runs.... the sequence of events is totally reproducible.....

I'm not sure what to look at next..... I feel it likely that the second call to the interrupt routine is not seeing what it expected or otherwise doing the right thing, but I'm well off the end of my knowledge there... Any help much appreciated!

Best wishes, John

Hi Kevin, sorry for delay, got pulled off onto other stuff.....

Well, I'm a bit bemused at what I've found, and thinking that I've misunderstood the business of running this driver in a non-operating-system environment:

The Semaphore Pend is entered very soon in the sl_Accept() routine:

_i16 sl_Accept(_i16 sd,
               SlSockAddr_t *addr,
               SlSocklen_t *addrlen)
{
    _SlSockAcceptMsg_u Msg;
    _SlReturnVal_t RetVal;
    SlSocketAddrResponse_u AsyncRsp;

    _u8 ObjIdx = MAX_CONCURRENT_ACTIONS;

    /* verify that this api is allowed. if not allowed then
       ignore the API execution and return immediately with an error */
    VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);

    Msg.Cmd.Sd = (_u8)sd;

    if((addr != NULL) && (addrlen != NULL))
    {
        /* If addr is present, addrlen has to be provided */
        Msg.Cmd.Family =
            (_u8)((sizeof(SlSockAddrIn_t) ==
                   *addrlen) ? SL_AF_INET : SL_AF_INET6);
    }
    else
    {
        /* In any other case, addrlen is ignored */
        Msg.Cmd.Family = (_u8)0;
    }

    ObjIdx = _SlDrvProtectAsyncRespSetting((_u8*)&AsyncRsp, ACCEPT_ID,
                                           (_u8)sd & SL_BSD_SOCKET_ID_MASK);

    if(MAX_CONCURRENT_ACTIONS == ObjIdx)
    {
        return(SL_POOL_IS_EMPTY);
    }

    /* send the command */
    VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlAcceptCmdCtrl, &Msg, NULL));
    VERIFY_PROTOCOL(Msg.Rsp.Sd == (_u8)sd);

    RetVal = Msg.Rsp.StatusOrLen;

    if(SL_OS_RET_CODE_OK == RetVal)
    {
#ifndef SL_TINY
        /* in case socket is non-blocking one, the async event should be received immediately */
        if(g_pCB->SocketNonBlocking & (1 << (sd & SL_BSD_SOCKET_ID_MASK)))
        {
            SL_DRV_SYNC_OBJ_WAIT_TIMEOUT(&g_pCB->ObjPool[ObjIdx].SyncObj,
                                         SL_DRIVER_TIMEOUT_SHORT,
                                         SL_OPCODE_SOCKET_ACCEPTASYNCRESPONSE
                                         );
        }
        else
#endif

When the interrupt occurs, the driver interrupt routine runs and appears to simply do a Spawn:

_SlReturnVal_t _SlDrvRxIrqHandler(void *pValue)
{
    (void)pValue;

    sl_IfMaskIntHdlr();

    RxIrqCnt++;

    if(TRUE == g_pCB->WaitForCmdResp)
    {
        OSI_RET_OK_CHECK(sl_SyncObjSignalFromIRQ(&g_pCB->CmdSyncObj));
    }
    else
    {
        (void)sl_Spawn((_SlSpawnEntryFunc_t)_SlDrvMsgReadSpawnCtx, NULL,
                       SL_SPAWN_FLAG_FROM_SL_IRQ_HANDLER);
    }
    return(SL_OS_RET_CODE_OK);
}

The interrupt routine then returns, and code execution returns to the Semaphore Pend routine..... and stays there until the Pend times out....

What is that Spawn trying to achieve? Given that I'm running in a non-operating-system environment, the CPU code execution is effectively captured by the Pend routine unless an interrupt occurs.... The Spawn routine called is in "nonos.c" and simply sets some variables:

#ifndef SL_PLATFORM_MULTI_THREADED

#include "nonos.h"

_SlNonOsCB_t g__SlNonOsCB;

_SlNonOsRetVal_t _SlNonOsSpawn(_SlSpawnEntryFunc_t pEntry,
                               void* pValue,
                               _u32 flags)
{
    _i8 i = 0;

    /* The parameter is currently not in use */
    (void)flags;

#ifndef SL_TINY
    for(i = 0; i < NONOS_MAX_SPAWN_ENTRIES; i++)
#endif
    {
        _SlNonOsSpawnEntry_t* pE = &g__SlNonOsCB.SpawnEntries[i];

        if(pE->IsAllocated == FALSE)
        {
            pE->pValue = pValue;
            pE->pEntry = pEntry;
            pE->IsAllocated = TRUE;
#ifndef SL_TINY
            break;
#endif
        }
    }

    return(NONOS_RET_OK);
}

Can you explain what should be happening here? Sorry if I'm missing something obvious!

Thanks, Best wishes,

John

Hi Kevin,

Thanks for reply! Now, what you say is somewhat what I'd guessed from that latest investigation, but it implies that the information in the Porting Guide is very incomplete....

The Porting Guide in the WiFi Library Programmers Guide says about sl_Task() in non-operating-system environment (page 242, and I'm sure in other places) "This function must be called from the main loop in non-OS platform..."

And I am indeed doing that.... sl_Task() is being called each time round my main loop. But the problem in this case is that the main loop is effectively being frozen by the call to sl_Accept() blocking at the Semaphore Pend..... so sl_Task() by definition cannot run during the execution of sl_Accept()......

So, from what you're saying, sl_Task() running each time round the loop is actually not sufficient, because it has to run during the execution of some other function calls, not just between calls. Is that correct?

If so, then that's not at all what the documentation implies (to me at least!), but is pretty easy to achieve. Can you confirm that sl_Task() is OK to be called completely asynchronously to the main program flow - that it doesn't matter if other WiFi library functions are executing when sl_Task() runs? If so, then I can call it from a low-priority timer interrupt so as it always runs regularly..... How often does sl_Task() ideally need to run? Once every 100ms OK?

Thanks for your help!

John