/** \brief analogout_write:\n * to execute analogout_write * * This function is mainly to execute analog output and the value is a ratio. * The upper/lower bound of DAC register input value is defined by * DAC_XXXXX_FULL_SCALE. The parameter "value" of this function should be * transfered to register value. * * \para dac_t * : obj * \para float : value */ void analogout_write(dac_t *obj, float value) { uint32_t dactemp; uint16_t dacnegtemp; PHAL_DAC_INIT_DAT pHalDacInitData = (PHAL_DAC_INIT_DAT)&(obj->DACpara); if (value < 0.0f) { HAL_DAC_WRITE32(pHalDacInitData->DACIdx, REG_DAC0_FIFO_WR, 0x00000000); } else if (value > 1.0f) { dactemp = (DAC_POSITIVE_FULL_SCALE<<16) | DAC_POSITIVE_FULL_SCALE; HAL_DAC_WRITE32(pHalDacInitData->DACIdx, REG_DAC0_FIFO_WR, dactemp); } else { if (value >= 0.5) { dactemp = (uint32_t)((((value-0.5)/0.5) * (2^12)) * DAC_POSITIVE_FULL_SCALE); dactemp = dactemp / (2^12); dactemp = (dactemp<<16) | dactemp; HAL_DAC_WRITE32(pHalDacInitData->DACIdx, REG_DAC0_FIFO_WR, dactemp); } else { dacnegtemp = (DAC_NEGATIVE_FULL_SCALE & 0x7FF); dacnegtemp = ((~dacnegtemp) + 1) & 0x7FF; dactemp = (uint32_t)(((0.5-value)/0.5) * (2^12) * dacnegtemp); dactemp = dactemp / (2^12); dactemp = 0x1000 - dactemp; //change to 2's complement dactemp = (dactemp<<16) | dactemp; HAL_DAC_WRITE32(pHalDacInitData->DACIdx, REG_DAC0_FIFO_WR, dactemp); } } }
//--------------------------------------------------------------------------------------------------- //Function Name: // HalDACInit8195a // // Description: // To initialize DAC module by using the given data. // // Arguments: // [in] VOID *Data - // The DAC parameter data struct. // // Return: // The status of the DeInit process. // _EXIT_SUCCESS if the initialization succeeded. // _EXIT_FAILURE if the initialization failed. // // Note: // None // // See Also: // NA // // Author: // By Jason Deng, 2014-04-15. // //--------------------------------------------------------------------------------------------------- RTK_STATUS HalDACInit8195a( IN VOID *Data ){ PHAL_DAC_INIT_DAT pHalDacInitData = (PHAL_DAC_INIT_DAT)Data; u32 DacTempDat; u8 DacTempIdx = pHalDacInitData->DACIdx; /* Enable DAC power cut */ DacTempDat = HAL_DAC_READ32(0, REG_DAC_PWR_CTRL); DacTempDat |= BIT_DAC_PWR_AUTO; HAL_DAC_WRITE32(0, REG_DAC_PWR_CTRL, DacTempDat); /* Disable DAC module first */ HAL_DAC_WRITE32(DacTempIdx, REG_DAC_CTRL, 0); /* Setup DAC module */ DacTempDat = 0; DacTempDat |= (BIT_CTRL_DAC_SPEED(pHalDacInitData->DACDataRate) | BIT_CTRL_DAC_ENDIAN(pHalDacInitData->DACEndian) | BIT_CTRL_DAC_FILTER_SETTLE(pHalDacInitData->DACFilterSet) | BIT_CTRL_DAC_BURST_SIZE(pHalDacInitData->DACBurstSz) | BIT_CTRL_DAC_DBG_SEL(pHalDacInitData->DACDbgSel) | BIT_CTRL_DAC_DSC_DBG_SEL(pHalDacInitData->DACDscDbgSel) | BIT_CTRL_DAC_BYPASS_DSC(pHalDacInitData->DACBPDsc) | BIT_CTRL_DAC_DELTA_SIGMA(pHalDacInitData->DACDeltaSig)); HAL_DAC_WRITE32(DacTempIdx, REG_DAC_CTRL, DacTempDat); return _EXIT_SUCCESS; }
/** \brief analogout_init:\n * to initialize DAC * * This function is mainly to initialize a DAC channel. * \para dac_t *: obj * \para PinName: pin */ void analogout_init(dac_t *obj, PinName pin) { uint32_t dac_idx; uint32_t DacTemp; PHAL_DAC_INIT_DAT pHalDacInitData = (PHAL_DAC_INIT_DAT)&(obj->DACpara); dac_idx = pin & 0x0F; /* Assign dac index */ pHalDacInitData->DACIdx = dac_idx; pHalDacInitData->DACEn = DAC_DISABLE; pHalDacInitData->DACDataRate = DAC_DATA_RATE_250K; pHalDacInitData->DACEndian = DAC_DATA_ENDIAN_LITTLE; pHalDacInitData->DACBurstSz = 10; pHalDacInitData->DACDbgSel = DAC_DBG_SEL_DISABLE; pHalDacInitData->DACDscDbgSel = DAC_DSC_DBG_SEL_DISABLE; pHalDacInitData->DACBPDsc = DAC_BYPASS_DSC_SEL_DISABLE; pHalDacInitData->DACDeltaSig = 0; pHalDacInitData->DACAnaCtrl0 = 0; pHalDacInitData->DACAnaCtrl1 = 0; pHalDacInitData->DACIntrMSK = DAC_FEATURE_DISABLED; /* DAC Function and Clock Enable*/ HalDACPinMuxInit(pHalDacInitData); HalDACInit8195a(pHalDacInitData); HAL_DAC_WRITE32(pHalDacInitData->DACIdx, REG_DAC_INTR_CTRL, (BIT_DAC_FIFO_FULL_EN | BIT_DAC_FIFO_OVERFLOW_EN | BIT_DAC_FIFO_STOP_EN | BIT_DAC__WRITE_ERROR_EN | BIT_DAC_DSC_OVERFLOW0_EN | BIT_DAC_DSC_OVERFLOW1_EN)); DBG_DAC_INFO("INTR MSK:%x\n", HAL_DAC_READ32(pHalDacInitData->DACIdx,REG_DAC_INTR_CTRL)); DacTemp = HAL_DAC_READ32(pHalDacInitData->DACIdx, REG_DAC_ANAPAR_DA1); DacTemp |= (BIT31); HAL_DAC_WRITE32(pHalDacInitData->DACIdx, REG_DAC_ANAPAR_DA1, DacTemp); DBG_DAC_INFO("REG_DAC_ANAPAR_DA1:%08x\n",HAL_DAC_READ32(pHalDacInitData->DACIdx, REG_DAC_ANAPAR_DA1)); DacTemp = HAL_DAC_READ32(pHalDacInitData->DACIdx, REG_DAC_CTRL); DacTemp |= BIT3; HAL_DAC_WRITE32(pHalDacInitData->DACIdx, REG_DAC_CTRL, DacTemp); DBG_DAC_INFO("REG_DAC_CTRL:%08x\n",DacTemp); pHalDacInitData->DACEn = DAC_ENABLE; HalDACEnableRtl8195a(pHalDacInitData); osDelay(6); //hardware needs some time to get ready }
/** \brief analogout_write_u16:\n * to execute analogout_write_u16 * * The register value of DAC input is a format of 2's complement. * The most maximum value of positive value drives DAC to output a voltage about 3.3V. * The most mimimum value of negative value drives DAC to output a voltage about 0. * And the middle value of 0x000 will drive DAC to output a voltage of half of max voltage. * * \para dac_t * : obj * \para float : value */ void analogout_write_u16(dac_t *obj, uint16_t value) { uint32_t dactemp; PHAL_DAC_INIT_DAT pHalDacInitData = (PHAL_DAC_INIT_DAT)&(obj->DACpara); /* To give a two point data */ dactemp = (value << 16) | value; HAL_DAC_WRITE32(pHalDacInitData->DACIdx, REG_DAC0_FIFO_WR, dactemp); }
//--------------------------------------------------------------------------------------------------- //Function Name: // HalI2CIntrCtrl8195a // // Description: // Modify the I2C interrupt mask according to the given value // // Arguments: // [in] VOID *Data - // The I2C parameter data struct. // // Return: // The status of the enable process. // _EXIT_SUCCESS if the de-initialization succeeded. // _EXIT_FAILURE if the de-initialization failed. // // Note: // None // // See Also: // NA // // Author: // By Jason Deng, 2014-02-18. // //--------------------------------------------------------------------------------------------------- RTK_STATUS HalDACIntrCtrl8195a( IN VOID *Data ){ PHAL_DAC_INIT_DAT pHalDacInitData = (PHAL_DAC_INIT_DAT)Data; HAL_DAC_WRITE32(pHalDacInitData->DACIdx, REG_DAC_INTR_CTRL, pHalDacInitData->DACIntrMSK); return _EXIT_SUCCESS; }
//--------------------------------------------------------------------------------------------------- //Function Name: // HalI2CInit8195a // // Description: // To initialize I2C module by using the given data. // // Arguments: // [in] VOID *Data - // The I2C parameter data struct. // // Return: // The status of the DeInit process. // _EXIT_SUCCESS if the initialization succeeded. // _EXIT_FAILURE if the initialization failed. // // Note: // None // // See Also: // NA // // Author: // By Jason Deng, 2014-04-02. // //--------------------------------------------------------------------------------------------------- RTK_STATUS HalDACDeInit8195a( IN VOID *Data ){ PHAL_DAC_INIT_DAT pHalDacInitData = (PHAL_DAC_INIT_DAT)Data; u32 DacTempDat; DacTempDat = HAL_DAC_READ32(pHalDacInitData->DACIdx, REG_DAC_CTRL); DacTempDat &= (~BIT_DAC_FIFO_EN); HAL_DAC_WRITE32(pHalDacInitData->DACIdx, REG_DAC_CTRL ,DacTempDat); return _EXIT_SUCCESS; }
//--------------------------------------------------------------------------------------------------- //Function Name: // HalI2CIntrCtrl8195a // // Description: // Modify the I2C interrupt mask according to the given value // // Arguments: // [in] VOID *Data - // The I2C parameter data struct. // // Return: // The status of the enable process. // _EXIT_SUCCESS if the de-initialization succeeded. // _EXIT_FAILURE if the de-initialization failed. // // Note: // None // // See Also: // NA // // Author: // By Jason Deng, 2014-02-18. // //--------------------------------------------------------------------------------------------------- RTK_STATUS HalDACEnableRtl8195a( IN VOID *Data ){ PHAL_DAC_INIT_DAT pHalDacInitData = (PHAL_DAC_INIT_DAT)Data; u32 DacTempDat; u8 DacTempIdx = pHalDacInitData->DACIdx; DacTempDat = HAL_DAC_READ32(DacTempIdx, REG_DAC_CTRL); DacTempDat &= (~BIT_DAC_FIFO_EN); DacTempDat |= BIT_CTRL_DAC_FIFO_EN(pHalDacInitData->DACEn); HAL_DAC_WRITE32(DacTempIdx, REG_DAC_CTRL, DacTempDat); return _EXIT_SUCCESS; }
//--------------------------------------------------------------------------------------------------- //Function Name: // RtkI2CInit // // Description: // According to the given I2C index, the related SAL_I2C_MNGT_ADPT pointer used // for retrieving each I2C data sturcture pointer will be reversely parsed first. // Then, initializing I2C HAL operation, initializing I2C interrupt (if needed), // initializing I2C DMA (if needed) and initializing I2C pinmux will be done. // User specified I2C configuration will be assigned to I2C initial data structure // (PHAL_I2C_INIT_DAT pHalI2CInitDat). I2C HAL initialization is executed after // all the configuration data taken. // In the end, I2C module is enabled as a final step of the whole initialization. // For a slave ack General Call support, an additional step may be followed after // the above steps. // // Arguments: // [in] VOID *Data - // I2C SAL handle // // Return: // The status of the I2C initialization process. // _EXIT_SUCCESS if the RtkI2CInit succeeded. // _EXIT_FAILURE if the RtkI2CInit failed. // // Note: // NA // // See Also: // NA // // Author: // By Jason Deng, 2014-04-03. // //---------------------------------------------------------------------------------------------------- RTK_STATUS RtkDACSend( IN VOID *Data ){ PSAL_DAC_HND pSalDACHND = (PSAL_DAC_HND) Data; PSAL_DAC_HND_PRIV pSalDACHNDPriv = NULL; PSAL_DAC_MNGT_ADPT pSalDACMngtAdpt = NULL; PHAL_GDMA_ADAPTER pHALDACGdmaAdpt = NULL; PHAL_GDMA_OP pHALDACGdmaOp = NULL; //PIRQ_HANDLE pIrqHandleDACGdma = NULL; /* To Get the SAL_I2C_MNGT_ADPT Pointer */ pSalDACHNDPriv = CONTAINER_OF(pSalDACHND, SAL_DAC_HND_PRIV, SalDACHndPriv); pSalDACMngtAdpt = CONTAINER_OF(pSalDACHNDPriv->ppSalDACHnd, SAL_DAC_MNGT_ADPT, pSalHndPriv); pHALDACGdmaAdpt = pSalDACMngtAdpt->pHalGdmaAdp; pHALDACGdmaOp = pSalDACMngtAdpt->pHalGdmaOp; //pIrqHandleDACGdma = pSalDACMngtAdpt->pIrqGdmaHnd; //NeoJou //pSalDACMngtAdpt->thread_id = osThreadGetId(); #if 0 while (1) { if (!(HAL_DAC_READ32(0,REG_DAC_INTR_STS) & BIT0) ) HAL_DAC_WRITE32(0,REG_DAC0_FIFO_WR,0xFFFF); } #endif #if 1 HalGdmaOpInit(pHALDACGdmaOp); pHALDACGdmaAdpt->GdmaCtl.BlockSize = pSalDACHND->pTXBuf->DataLen; pHALDACGdmaAdpt->ChSar = (u32)pSalDACHND->pTXBuf->pDataBuf; pHALDACGdmaAdpt->ChDar = (u32)(DAC_REG_BASE+(pSalDACHND->DevNum*0x800)); //DBG_8195A("src addr:%x\n", pHALDACGdmaAdpt->ChSar); //DBG_8195A("dst addr:%x\n", pHALDACGdmaAdpt->ChDar); pHALDACGdmaOp->HalGdmaChSeting(pHALDACGdmaAdpt); pHALDACGdmaOp->HalGdmaChEn(pHALDACGdmaAdpt); #endif return _EXIT_SUCCESS; }
//--------------------------------------------------------------------------------------------------- //Function Name: // RtkI2CInit // // Description: // According to the given I2C index, the related SAL_I2C_MNGT_ADPT pointer used // for retrieving each I2C data sturcture pointer will be reversely parsed first. // Then, initializing I2C HAL operation, initializing I2C interrupt (if needed), // initializing I2C DMA (if needed) and initializing I2C pinmux will be done. // User specified I2C configuration will be assigned to I2C initial data structure // (PHAL_I2C_INIT_DAT pHalI2CInitDat). I2C HAL initialization is executed after // all the configuration data taken. // In the end, I2C module is enabled as a final step of the whole initialization. // For a slave ack General Call support, an additional step may be followed after // the above steps. // // Arguments: // [in] VOID *Data - // I2C SAL handle // // Return: // The status of the I2C initialization process. // _EXIT_SUCCESS if the RtkI2CInit succeeded. // _EXIT_FAILURE if the RtkI2CInit failed. // // Note: // NA // // See Also: // NA // // Author: // By Jason Deng, 2014-04-03. // //---------------------------------------------------------------------------------------------------- RTK_STATUS RtkDACInit( IN VOID *Data ){ PSAL_DAC_HND pSalDACHND = (PSAL_DAC_HND) Data; PSAL_DAC_HND_PRIV pSalDACHNDPriv = NULL; PSAL_DAC_MNGT_ADPT pSalDACMngtAdpt = NULL; //PHAL_DAC_INIT_DAT pHalDACInitDat = NULL; PHAL_DAC_OP pHalDACOP = NULL; /* To Get the SAL_I2C_MNGT_ADPT Pointer */ pSalDACHNDPriv = CONTAINER_OF(pSalDACHND, SAL_DAC_HND_PRIV, SalDACHndPriv); pSalDACMngtAdpt = CONTAINER_OF(pSalDACHNDPriv->ppSalDACHnd, SAL_DAC_MNGT_ADPT, pSalHndPriv); //pHalDACInitDat = pSalDACMngtAdpt->pHalInitDat; pHalDACOP = pSalDACMngtAdpt->pHalOp; /* Check the input I2C index first */ if (RtkDACIdxChk(pSalDACHND->DevNum)) return _EXIT_FAILURE; #if 0 /* Check the input I2C operation type */ if (RtkI2COpTypeChk(pSalI2CHND)) return _EXIT_FAILURE; #endif /* DAC Initialize HAL Operations */ HalDACOpInit(pHalDACOP); /* DAC Interrupt Initialization */ #if DAC_INTR_OP_TYPE RtkDACIrqInit(pSalDACHND); #endif /* DAC DMA Initialization */ #if DAC_DMA_OP_TYPE RtkDACDMAInit(pSalDACHND); #endif /* DAC Function and Clock Enable*/ RtkDACPinMuxInit(pSalDACHND); pHalDACOP->HalDACInit(pSalDACHND->pInitDat); #if 1 HAL_DAC_WRITE32(pSalDACHND->DevNum, REG_DAC_INTR_CTRL, (BIT_DAC_FIFO_FULL_EN | BIT_DAC_FIFO_OVERFLOW_EN | BIT_DAC_FIFO_STOP_EN | BIT_DAC__WRITE_ERROR_EN | BIT_DAC_DSC_OVERFLOW0_EN | BIT_DAC_DSC_OVERFLOW1_EN)); #else HAL_DAC_WRITE32(pSalDACHND->DevNum, REG_DAC_INTR_CTRL, (BIT_DAC_FIFO_FULL_EN| BIT_DAC_FIFO_OVERFLOW_EN| BIT_DAC_FIFO_STOP_EN| BIT_DAC__WRITE_ERROR_EN| BIT_DAC_DSC_OVERFLOW0_EN| BIT_DAC_DSC_OVERFLOW1_EN)); #endif DBG_8195A("intr msk:%x\n", HAL_DAC_READ32(pSalDACHND->DevNum,REG_DAC_INTR_CTRL)); pSalDACHND->pInitDat->DACEn = DAC_ENABLE; pHalDACOP->HalDACEnable(pSalDACHND->pInitDat); /* DAC Device Status Update */ pSalDACHND->DevSts = DAC_STS_IDLE; return _EXIT_SUCCESS; }