source: svn/trunk/newcon3bcm2_21bu/dta/src/nexus/bsettop_rfm.c @ 49

/***************************************************************************
 *     Copyright (c) 2012, Broadcom Corporation
 *     All Rights Reserved
 *     Confidential Property of Broadcom Corporation
 *
 *  THIS SOFTWARE MAY ONLY BE USED SUBJECT TO AN EXECUTED SOFTWARE LICENSE
 *  AGREEMENT  BETWEEN THE USER AND BROADCOM.  YOU HAVE NO RIGHT TO USE OR
 *  EXPLOIT THIS MATERIAL EXCEPT SUBJECT TO THE TERMS OF SUCH AN AGREEMENT.
 *
 * $brcm_Workfile:  $
 * $brcm_Revision:  $
 * $brcm_Date: $
 *
 * Module Description:
 *
 * Revision History:
 *
 * $brcm_Log:  $
 *
 ***************************************************************************/

#include "nexus_platform.h"
#include "nexus_types.h"
#if NEXUS_NUM_RFM_OUTPUTS
#include "nexus_rfm.h"
#endif
#include "bsettop_rfm.h"
#include "bos_task_priorities.h"
#include "nexus_gpio.h"

#define BRFM_TASK_STACK_WORDS 256
struct brfm
{
#if NEXUS_NUM_RFM_OUTPUTS
        NEXUS_RfmHandle rfmHandle;
#else
        NEXUS_I2cHandle i2cHandle;
#endif
        NEXUS_GpioHandle gpio;
        BKNI_EventHandle event;
        NEXUS_GpioValue lastValue;

        unsigned int task_stack[BRFM_TASK_STACK_WORDS];
        b_task_t task_h;
};

static struct brfm s_rfm;

#if (BCHP_CHIP==7552)
#define BRFM_GPIO_NUM    20
#elif (BCHP_CHIP==7344)
#define BRFM_GPIO_NUM           5
#endif

BDBG_MODULE(brfm);

static void rfm_gpio_interrupt(void *context, int param)
{
        BSTD_UNUSED(param);
        BKNI_SetEvent((BKNI_EventHandle)context);
}


static void rfm_task(void *arg)
{
        NEXUS_GpioStatus gpioStatus;
        NEXUS_Error err;

#if NEXUS_NUM_RFM_OUTPUTS
        NEXUS_RfmSettings rfmSettings;
#else
        static uint8_t channel3Data[4] = {0x80,0x00,0x1e,0xa3};
        static uint8_t channel4Data[4] = {0x80,0x00,0x21,0xa3};
        uint8_t *pData;
#endif
        brfm_t rfm = (brfm_t)arg;

        while (1) 
        {
                BKNI_WaitForEvent(rfm->event, 0xFFFFFFFF);
                err = NEXUS_Gpio_GetStatus(s_rfm.gpio, &gpioStatus);
                if (err != NEXUS_SUCCESS) {
                        BDBG_WRN(("NEXUS_Gpio_GetStatus failed"));
                        continue;
                }
                if (gpioStatus.value != rfm->lastValue) 
                {
                        rfm->lastValue = gpioStatus.value;
                        BDBG_ERR(("%s:%d, value = %d", __FUNCTION__, __LINE__, rfm->lastValue));
#if NEXUS_NUM_RFM_OUTPUTS
                        NEXUS_Rfm_GetSettings(rfm->rfmHandle, &rfmSettings);
                        if (rfm->lastValue == NEXUS_GpioValue_eHigh) {
                                rfmSettings.channel = 4;
                        }
                        else {
                                rfmSettings.channel = 3;
                        }
                        NEXUS_Rfm_SetSettings(rfm->rfmHandle, &rfmSettings);
#else
                        if (rfm->lastValue == NEXUS_GpioValue_eHigh) {
                                pData = channel4Data;
                        }
                        else {
                                pData = channel3Data;
                        }
                        NEXUS_I2c_WriteNoAddr(rfm->i2cHandle, 0x65, pData, 4);
#endif
                }
        }
}

/*
 * Summary:
 * Open and allocate RFM resources.
 *
 * Description:
 * On most platforms, the rfm_id is simply an index of the rf modulator.
 *
 **/
brfm_t brfm_open(
        int rfm_id    /* - index used to identify a particular rfm */
        )
{

        NEXUS_GpioSettings gpioSettings;
        NEXUS_PlatformConfiguration platformConfig;
        NEXUS_GpioStatus gpioStatus;
        b_task_params task_params;
#if NEXUS_NUM_RFM_OUTPUTS
        NEXUS_RfmSettings rfmSettings;
#endif
        BSTD_UNUSED(rfm_id);

        BKNI_Memset(&s_rfm, 0, sizeof(s_rfm));

        BKNI_CreateEvent(&s_rfm.event);
        
        NEXUS_Gpio_GetDefaultSettings(NEXUS_GpioType_eStandard, &gpioSettings);
        gpioSettings.mode = NEXUS_GpioMode_eInput;
        gpioSettings.interruptMode = NEXUS_GpioInterrupt_eEdge;
        gpioSettings.interrupt.callback = rfm_gpio_interrupt;
        gpioSettings.interrupt.context = s_rfm.event;
        s_rfm.gpio = NEXUS_Gpio_Open(NEXUS_GpioType_eAonStandard, BRFM_GPIO_NUM, &gpioSettings);

        NEXUS_Platform_GetConfiguration(&platformConfig);
#if NEXUS_NUM_RFM_OUTPUTS
        NEXUS_Rfm_GetDefaultSettings(&rfmSettings);

        NEXUS_Gpio_GetStatus(s_rfm.gpio, &gpioStatus);
        if (gpioStatus.value == NEXUS_GpioValue_eHigh) {
                /* channel 4 */
                BDBG_WRN(("Channel 4"));
                rfmSettings.channel = 4;
        }
        else { 
                BDBG_WRN(("Channel 3"));
                rfmSettings.channel = 3;
        }
        s_rfm.rfmHandle = platformConfig.outputs.rfm[0];

        NEXUS_Rfm_SetSettings(s_rfm.rfmHandle, &rfmSettings);
#else
        /* in nexus, set the correct channel when initializing platform */      
        s_rfm.i2cHandle = platformConfig.i2c[NEXUS_I2C_CHANNEL_EXT_RFM];
#endif
        s_rfm.lastValue = gpioStatus.value;

        task_params.name = "RFM_TASK";
        task_params.priority = RFM_PRIORITY;
        task_params.stack_size = BRFM_TASK_STACK_WORDS;
        task_params.stack = s_rfm.task_stack;
        bos_start_task(&(s_rfm.task_h), &task_params, rfm_task, &s_rfm);

        /* set initial RF channel */
        BKNI_SetEvent((BKNI_EventHandle)s_rfm.event);
        return &s_rfm;
}

void brfm_close(brfm_t rfm)
{
        BDBG_ASSERT(rfm);
        if (rfm->task_h)
                bos_stop_task(rfm->task_h);
        if (rfm->gpio)
                NEXUS_Gpio_Close(rfm->gpio);

        rfm->gpio = NULL;
        rfm->task_h = 0;
        BKNI_DestroyEvent(rfm->event);
}