CC3120: Porting Simple Link Host Driver to STM32

/*
 *   Copyright (C) 2015 Texas Instruments Incorporated
 *
 *   All rights reserved. Property of Texas Instruments Incorporated.
 *   Restricted rights to use, duplicate or disclose this code are
 *   granted through contract.
 *
 *   The program may not be used without the written permission of
 *   Texas Instruments Incorporated or against the terms and conditions
 *   stipulated in the agreement under which this program has been supplied,
 *   and under no circumstances can it be used with non-TI connectivity device.
 *
 */
/******************************************************************************
*     msp_pal.c
*
*    Simplelink Wi-Fi platform abstraction file for MSP432
******************************************************************************/
#include <ti/drivers/net/wifi/porting/cc_pal.h>
#include <ti/drivers/net/wifi/simplelink.h>
#include "stm32f3xx_hal.h"
#include "FreeRTOS.h"
#include "task.h"
/****************************************************************************
   GLOBAL VARIABLES
****************************************************************************/
volatile Fd_t g_SpiFd = 0;
SL_P_EVENT_HANDLER g_Host_irq_Hndlr = NULL;
extern SPI_HandleTypeDef hspi3;
extern P_EVENT_HANDLER cc3120extiHandler;
/****************************************************************************
   CONFIGURATION VARIABLES
****************************************************************************/


/****************************************************************************
   CONFIGURATION FUNCTION DEFINITION
****************************************************************************/


/****************************************************************************
   LOCAL FUNCTION DEFINITIONS
****************************************************************************/
Fd_t spi_Open(char *ifName,
              unsigned long flags)
{

  return 0;
}

int spi_Close(Fd_t fd)
{
  return 0;
}

int spi_Read(Fd_t fd,
             unsigned char *pBuff,
             int len)
{
  int retVal = -1;

  HAL_GPIO_WritePin(cc3120_cs_GPIO_Port, cc3120_cs_Pin, 0x00);
  retVal = HAL_SPI_Receive(&hspi3, pBuff, len, 1000);
  HAL_GPIO_WritePin(cc3120_cs_GPIO_Port, cc3120_cs_Pin, 0x01);
  return retVal;

}

int spi_Write(Fd_t fd,
              unsigned char *pBuff,
              int len)
{
  int retVal = -1;

  HAL_GPIO_WritePin(cc3120_cs_GPIO_Port, cc3120_cs_Pin, 0x00);
  retVal = HAL_SPI_Transmit(&hspi3, pBuff, len, 1000);
  HAL_GPIO_WritePin(cc3120_cs_GPIO_Port, cc3120_cs_Pin, 0x01);
  return retVal;

  return 0;
}

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


void NwpMaskInterrupt()
{
}

void NwpUnMaskInterrupt()
{
}

void NwpPowerOnPreamble(void)
{
    /* Maybe start timer here? */
}

void NwpPowerOn(void)
{
  HAL_GPIO_WritePin(cc3120_enable_GPIO_Port, cc3120_enable_Pin, 0x01);
  HAL_Delay(500);
}

void NwpPowerOff(void)
{
  HAL_GPIO_WritePin(cc3120_enable_GPIO_Port, cc3120_enable_Pin, 0x00);
}

int SyncObjCreate(SemaphoreP_Handle* pSemHandle)
{
	(*pSemHandle) = xSemaphoreCreateBinary();

    if(!(*(pSemHandle)))
    {
        return(-1);
    }

    return(0);
}

int SyncObjDelete(SemaphoreP_Handle* pSemHandle) {
  /* To be implemented */
  vSemaphoreDelete(*pSemHandle);
  return 0;
}

int SyncObjSignal(SemaphoreP_Handle* pSemHandle) {
  /* To be implemented */
	unsigned char retVal;
	retVal = xSemaphoreGive(*pSemHandle);
	if(retVal == pdTRUE) {
		return 0;
	}else{
		return 1;
	}
}

int  SyncObjSignalFromIRQ(SemaphoreP_Handle * pSemHandle) {
  /* To be implemented */
	xSemaphoreGiveFromISR(*pSemHandle, NULL);
  return 0;
}

int SyncObjWait(SemaphoreP_Handle* pSemHandle, uint32_t Timeout) {
  /* To be implemented */
	unsigned char retVal;
	retVal = xSemaphoreTake((*pSemHandle),Timeout);
	if(retVal == pdTRUE) {
		return 0;
	}else{
		return 1;
	}
}

int SemaphoreP_delete_handle(SemaphoreP_Handle* pSemHandle)
{
//    SemaphoreP_delete(*(pSemHandle));
//    return(SemaphoreP_OK);
  return 0;
}

int LockObjDelete(MutexP_Handle* pMutexHandle) {
  /* To be implemented */
  return 0;
}

int LockObjLock(MutexP_Handle*pMutexHandle, uint32_t Timeout ) {
  /* To be implemented */
	unsigned char retVal;
	retVal = xSemaphoreTake((*pMutexHandle),Timeout);
	if(retVal == pdTRUE) {
		return 0;
	}else{
		return 1;
	}
}

int LockObjUnlock(MutexP_Handle* pLockObj) {

	unsigned char retVal;
	retVal = xSemaphoreGive(*pLockObj);
	if(retVal == pdTRUE) {
		return 0;
	}else{
		return 1;
	}
}

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


int Mutex_create_handle(MutexP_Handle* pMutexHandle)
{
	(*pMutexHandle) = xSemaphoreCreateMutex();

    if(!(*(pMutexHandle)))
    {
        return(-1);
    }

  return 0;
}

int MutexP_delete_handle(MutexP_Handle* pMutexHandle)
{
  vSemaphoreDelete(*pMutexHandle);
  return 0;
}

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

int Mutex_lock(MutexP_Handle pMutexHandle)
{
//    MutexP_lock(pMutexHandle);
//    return (MutexP_OK);
  return 0;
}

unsigned long TimerGetCurrentTimestamp()
{
	TickType_t systemTick;
	systemTick = xTaskGetTickCount();
	return (unsigned long)systemTick;
//    return (ClockP_getSystemTicks());
}