CC3135MOD: SL_API_ABORTED (-2005) after sl_start

/*
 * cc_pal.c - CC32xx Host Driver Implementation
 *
 * Copyright (C) 2017 Texas Instruments Incorporated - http://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.
 *
*/
/******************************************************************************
*   cc_pal.c
*
*   SimpleLink Wi-Fi abstraction file for CC32xx
******************************************************************************/

/* Board includes */
#include <stdio.h>
#include <ti/drivers/net/wifi/porting/cc_pal.h>
#include <ti/drivers/net/wifi/wlan.h>
#include "user.h"
#include "../../../../../../Inc/main.h"
#include <ti/drivers/net/wifi/simplelink.h>

/****************************************************************************
   LOCAL FUNCTION DEFINITIONS
****************************************************************************/

void NwpPowerOn(void)       { HAL_GPIO_WritePin (nHIB_GPIO_PORT, nHIB_PIN, GPIO_PIN_SET);  }
void NwpPowerOff(void)      { HAL_GPIO_WritePin (nHIB_GPIO_PORT, nHIB_PIN, GPIO_PIN_RESET); HAL_Delay(200);}

#define SPI_TIMEOUT         0x1000
#define ASSERT_CS           ( HAL_GPIO_WritePin (GPIOB, GPIO_PIN_11, GPIO_PIN_RESET))
#define DEASSERT_CS         ( HAL_GPIO_WritePin (GPIOB, GPIO_PIN_11, GPIO_PIN_SET))

SPI_HandleTypeDef    hspi1;

extern u32 gSys_Timer_G_1MS;

//#define DEBUG_SPI_RXTX 1

//****************************************************************************
//                          LOCAL FUNCTIONS
//****************************************************************************

Fd_t spi_Open(char *ifName, unsigned long flags)
{
    printf("\r\n spi_Open");    
    hspi1.Instance               = SPI2;
    hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4;
    hspi1.Init.Direction         = SPI_DIRECTION_2LINES;
    hspi1.Init.CLKPhase          = SPI_PHASE_1EDGE;
    hspi1.Init.CLKPolarity       = SPI_POLARITY_LOW; 
    hspi1.Init.CRCCalculation    = SPI_CRCCALCULATION_DISABLE;
    hspi1.Init.CRCPolynomial     = 7;
    hspi1.Init.DataSize          = SPI_DATASIZE_8BIT;
    hspi1.Init.FirstBit          = SPI_FIRSTBIT_MSB;
    hspi1.Init.NSS               = SPI_NSS_SOFT;
    hspi1.Init.TIMode            = SPI_TIMODE_DISABLE;
    
    hspi1.Init.Mode = SPI_MODE_MASTER;

    if(HAL_SPI_Init(&hspi1) != HAL_OK)
    {
      printf("\r\n HAL_SPI_Init Fail");
    }

    //NwpOff ();
    DEASSERT_CS;
    HAL_Delay(50);
    printf("\r\n spi_Open done");

    return 0;
}


int spi_Close(Fd_t fd)
{
   printf("\r\n spi_Close");
   HAL_SPI_DeInit (&hspi1);
   return 0;
}


int spi_Read(Fd_t fd, unsigned char *pBuff, int len)
{    
    //  printf("\r\n spi_Read %d", len);    
    ASSERT_CS;    
    HAL_StatusTypeDef status = HAL_SPI_Receive (&hspi1, pBuff, len, SPI_TIMEOUT);
    DEASSERT_CS;
#ifdef DEBUG_SPI_RXTX    
    printf("\r\n spi_Read %d", len); 
    for(int i=0; i<len; i++)
      printf(" %02X", pBuff[i]);
#endif
    return len;
}


int spi_Write(Fd_t fd, unsigned char *pBuff, int len)
{
#ifdef DEBUG_SPI_RXTX  
    printf("\r\n spi_Write %d", len);
    for(int i=0; i<len; i++)
      printf(" %02X", pBuff[i]);
#endif
    ASSERT_CS;    
    HAL_StatusTypeDef status = HAL_SPI_Transmit (&hspi1, pBuff, len, SPI_TIMEOUT);
    DEASSERT_CS;
    return len;
}

P_EVENT_HANDLER pISR = 0;

int NwpRegisterInterruptHandler(P_EVENT_HANDLER InterruptHdl , void* pValue)
{
    pISR = InterruptHdl;
    return 0;
}


void NwpMaskInterrupt()
{
    HAL_NVIC_EnableIRQ (SPIWifi_IRQn);
}


void NwpUnMaskInterrupt()
{
    HAL_NVIC_DisableIRQ (SPIWifi_IRQn);
}



/*

int Mutex_create_handle(MutexP_Handle* pMutexHandle)
{
    MutexP_Params params;

    MutexP_Params_init(&params);

    params.callback = tiDriverSpawnCallback;

    (*(pMutexHandle)) = MutexP_create(&params);

    if(!(*(pMutexHandle)))
    {
        return Mutex_FAILURE ;
    }

    return Mutex_OK;
}

int  MutexP_delete_handle(MutexP_Handle* pMutexHandle)
{
    MutexP_delete(*(pMutexHandle));
    return(Mutex_OK);
}

int Mutex_unlock(MutexP_Handle pMutexHandle)
{
    MutexP_unlock(pMutexHandle, 0);
    return(Mutex_OK);
}


int Mutex_lock(MutexP_Handle pMutexHandle)
{
    MutexP_lock(pMutexHandle);
    return(Mutex_OK);
}

int SemaphoreP_create_handle(SemaphoreP_Handle* pSemHandle)
{
    SemaphoreP_Params params;

    SemaphoreP_Params_init(&params);

    params.mode = SemaphoreP_Mode_BINARY;

    params.callback = tiDriverSpawnCallback;

    (*(pSemHandle)) = SemaphoreP_create(1, &params);

    if(!(*(pSemHandle)))
    {
        return Semaphore_FAILURE ;
    }

    return Semaphore_OK;
}

int SemaphoreP_delete_handle(SemaphoreP_Handle* pSemHandle)
{
    SemaphoreP_delete(*(pSemHandle));
    return Semaphore_OK;
}

int SemaphoreP_post_handle(SemaphoreP_Handle* pSemHandle)
{
    SemaphoreP_post(*(pSemHandle));
    return Semaphore_OK;
}
*/


unsigned long TimerGetCurrentTimestamp()
{
   // return (ClockP_getSystemTicks());
  return gSys_Timer_G_1MS;
}

void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{  
  if((GPIO_Pin == WIFI_nATTN_PIN) && (NULL != pISR) )
  {       
   // printf("\r\n HAL_GPIO_EXTI_Callback %d", GPIO_Pin);    
    pISR();
  }
}

void NwpWaitForShutDownInd()
{
  /*
    volatile unsigned long nwp_wakup_ind = HWREG(NWP_LPDS_WAKEUPCFG);
    _SlTimeoutParams_t SlTimeoutInfo = {0};

    _SlDrvStartMeasureTimeout(&SlTimeoutInfo, NWP_LPDS_WAKEUPCFG_TIMEOUT_MSEC);

    while(nwp_wakup_ind != NWP_LPDS_WAKEUPCFG_APPS2NWP)
    {
        if(_SlDrvIsTimeoutExpired(&SlTimeoutInfo))
        {
            return;
        }
        nwp_wakup_ind = HWREG(NWP_LPDS_WAKEUPCFG);
    }

    return ;
*/
}