cc_pal.c

/*
 *   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/SPI.h>
#include <ti/drivers/GPIO.h>
#include <ti/drivers/net/wifi/porting/cc_pal.h>
#include <ti/drivers/net/wifi/simplelink.h>

#define MSP_EXP432P401R_HOST_IRQ                 (2)        /* Board P2.5 */
#define MSP_EXP432P401R_nHIB_pin                 (5)        /* Board P4.1 */
#define MSP_EXP432P401R_CS_pin                   (6)        /* Board P3.0 */
#define MAX_DMA_TRANSACTION_SIZE                 (1024)
#define SPI_RATE_8M                              (8000000)
#define SPI_RATE_10M                             (10000000)
#define SPI_RATE_13M                             (13000000)
#define SPI_RATE_20M                             (20000000)
#define ASSERT_CS()                              (GPIO_write(MSP_EXP432P401R_CS_pin, 0))
#define DEASSERT_CS()                            (GPIO_write(MSP_EXP432P401R_CS_pin, 1))

/****************************************************************************
                      GLOBAL VARIABLES
****************************************************************************/

volatile Fd_t       g_SpiFd = 0;
SL_P_EVENT_HANDLER  g_Host_irq_Hndlr = NULL;

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

Fd_t spi_Open(char *ifName, unsigned long flags)
{
    void *lspi_hndl;
    SPI_Params SPI_Config;

    /* configure the SPI settings */
    SPI_Config.transferMode = SPI_MODE_BLOCKING;
    SPI_Config.mode = SPI_MASTER;
    SPI_Config.bitRate = 20000000;
    SPI_Config.dataSize = 8;
    SPI_Config.frameFormat = SPI_POL0_PHA0;

    /* Initialize the SPI config structure */
    SPI_Params_init(&SPI_Config);

    /* Open SPI interface with SPI_Config parameters */
    lspi_hndl = SPI_open(0, &SPI_Config);
    if(NULL == lspi_hndl)
    {
        return -1;
    }
    else
    {
        return (Fd_t)lspi_hndl;
    }
}


int spi_Close(Fd_t fd)
{
    SPI_close((void *)fd);
    return 0;
}


int spi_Read(Fd_t fd, unsigned char *pBuff, int len)
{    
    SPI_Transaction transact_details;
    int read_size = 0;
    
    ASSERT_CS();

    /* check if the link SPI has been initialized successfully */
    if(fd < 0)
    {
        DEASSERT_CS();
        return -1;
    }
    
    transact_details.txBuf = NULL;
    transact_details.arg = NULL;
    transact_details.rxBuf = (void*)(pBuff);

    while(len > 0)
    {
        if(len > MAX_DMA_TRANSACTION_SIZE)
        {
            transact_details.count = MAX_DMA_TRANSACTION_SIZE ;
        }
        else
        {
            transact_details.count = len ;
        }

        if(SPI_transfer((SPI_Handle)fd, &transact_details))
        {
            read_size += transact_details.count;
            len = len - transact_details.count;
            transact_details.rxBuf = ((unsigned char *)(transact_details.rxBuf) + read_size);
        }
        else
        {
            DEASSERT_CS();
            return -1;
        }
    }

    DEASSERT_CS();

    return(read_size);
}


int spi_Write(Fd_t fd, unsigned char *pBuff, int len)
{
    SPI_Transaction transact_details;
    int write_size = 0;
    
    ASSERT_CS();

    /* check if the link SPI has been initialized successfully */
    if(fd < 0)
    {
        DEASSERT_CS();
        return -1;
    }

    transact_details.rxBuf = NULL;
    transact_details.arg = NULL;
    transact_details.txBuf = (void*)(pBuff);

    while(len > 0)
    {
        if(len > MAX_DMA_TRANSACTION_SIZE)
        {
            transact_details.count = MAX_DMA_TRANSACTION_SIZE ;
        }
        else
        {
            transact_details.count = len ;
        }

        if(SPI_transfer((SPI_Handle)fd, &transact_details))
        {
            write_size += transact_details.count;
            len = len - transact_details.count;
            transact_details.txBuf = ((unsigned char *)(transact_details.txBuf) + write_size);
        }
        else
        {
            DEASSERT_CS();
            return -1;
        }
    }

     DEASSERT_CS();

    return(write_size);
}


int NwpRegisterInterruptHandler(P_EVENT_HANDLER InterruptHdl , void* pValue)
{
    /* Check for unregister condition */
    if(NULL == InterruptHdl)
    {
        GPIO_disableInt(MSP_EXP432P401R_HOST_IRQ);
        GPIO_clearInt(MSP_EXP432P401R_HOST_IRQ);
        g_Host_irq_Hndlr = NULL;
        return 0;
    }
    else if(NULL == g_Host_irq_Hndlr)
    {
        g_Host_irq_Hndlr = InterruptHdl;
        GPIO_setCallback(MSP_EXP432P401R_HOST_IRQ, HostIrqGPIO_callback);
        GPIO_enableInt(MSP_EXP432P401R_HOST_IRQ);
        return 0;
    }
    else
    {
        /* An error occurred */
        return -1;
    }
}


void HostIrqGPIO_callback(uint_least8_t index)
{
    if((index == MSP_EXP432P401R_HOST_IRQ) && (NULL != g_Host_irq_Hndlr))
    {
        g_Host_irq_Hndlr(0);
    }
}


void NwpMaskInterrupt()
{

}


void NwpUnMaskInterrupt()
{

}


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


void NwpPowerOn(void)
{
    GPIO_write(MSP_EXP432P401R_nHIB_pin, 1);
    /* wait 5msec */
    ClockP_usleep(5000);
}


void NwpPowerOff(void)
{
    GPIO_write(MSP_EXP432P401R_nHIB_pin, 0);
    /* wait 5msec */
    ClockP_usleep(5000);
}


int Semaphore_create_handle(SemaphoreP_Handle* pSemHandle)
{
    (*(pSemHandle)) = SemaphoreP_create(0, NULL);

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

    return SemaphoreP_OK;
}


int Mutex_create_handle(MutexP_Handle* pMutexHandle)
{

    (*(pMutexHandle)) = MutexP_create(NULL);

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

    return MutexP_OK;
}


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


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

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