gatsby/KY-XTZ
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
047446fd9b348237651b648a45e742fde8ac9f56
KY-XTZ/src/hardware/headless.c
T

1170 lines
35 KiB
C
Raw Blame History

/******************************************************************************* * @file ad9371/src/app/headless.c
* @brief Implementation of Main Function.
********************************************************************************
* Copyright 2017(c) Analog Devices, Inc.
*
* All rights reserved.
*
* 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 Analog Devices, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
* - The use of this software may or may not infringe the patent rights
* of one or more patent holders. This license does not release you
* from the requirement that you obtain separate licenses from these
* patent holders to use this software.
* - Use of the software either in source or binary form, must be run
* on or directly connected to an Analog Devices Inc. component.
*
* THIS SOFTWARE IS PROVIDED BY ANALOG DEVICES "AS IS" AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, NON-INFRINGEMENT,
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL ANALOG DEVICES BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, INTELLECTUAL PROPERTY RIGHTS, 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.
*******************************************************************************/
/***************************** Include Files ********************************/
#include "headless.h"
#include "delay.h"
/************************** Constant Definitions *****************************/
/**************************** Type Definitions *******************************/
/***************** Macros (Inline Functions) Definitions *********************/
/************************** Variable Definitions *****************************/
XScuGic Intc;
/************************** Function Prototypes ******************************/
int HARDWARE_initialize()
{
int Status;
// use configuration
mykDevice.rx->rxPllLoFrequency_Hz = 720000000u;
mykDevice.tx->txPllLoFrequency_Hz = 720000000u;
mykDevice.tx->tx1Atten_mdB = 10000;
mykDevice.tx->tx2Atten_mdB = 10000;
Status = HARDWARE_ad9371Config();
if (Status != ADIERR_OK)
{
return ADIERR_FAILED;
}
// /**********************************************************/
// /************ AD9371 Dynamical Reconfiguration ************/
// /**********************************************************/
// Status = HW_ad9371DynamicCfgInit();
// if (Status != ADIERR_OK){
// HW_PRINT("HW:: AD9371 dynamic configuration initialization failed!\n");
// return ADIERR_FAILED;
// }
//
// HW_PRINT("HW:: AD9371 ready to be reconfigured!\n");
//
// // main loop
// while(1);
// never reach
return ADIERR_OK;
}
// this function is NOT safe
int HARDWARE_ad9371Config(void)
{
int Status;
uint8_t reg508;
uint8_t framerStatus;
uint8_t obsFramerStatus;
uint8_t deframerStatus;
/**********************************************************/
/*********** Initialize Configuration Interface ***********/
/**********************************************************/
Status = CMB_initPlatform();
if (Status != ADIERR_OK)
{
return ADIERR_FAILED;
}
Status = HW_adiCfgProfileInit();
if (Status != ADIERR_OK)
{
return ADIERR_FAILED;
}
HW_PRINT("HW:: Initialize configuration interface done!\n");
/**********************************************************/
/****************** AD9528 Configuration ******************/
/**********************************************************/
Status = HW_9528Config(ad9528Init);
if (Status != ADIERR_OK)
{
return ADIERR_FAILED;
}
HW_PRINT("HW:: AD9528 configuration done!\n");
Status = HW_9528GetLockStatus(ad9528Init, &reg508);
if (Status != ADIERR_OK)
{
return ADIERR_FAILED;
}
HW_PRINT("HW:: AD9528 REG508: 0x%02x\n", reg508);
/**********************************************************/
/****************** AD9371 Configuration ******************/
/**********************************************************/
Status = HW_9371Config(ad9528Init, &mykDevice);
if (Status != ADIERR_OK)
{
return ADIERR_FAILED;
}
Status = HW_9371CheckJesdStatus(&mykDevice, &framerStatus,
&obsFramerStatus, &deframerStatus);
if (Status != ADIERR_OK)
{
return ADIERR_FAILED;
}
else
{
// typical value: 0x3E
HW_PRINT("HW:: RxFramerStatus = 0x%x\n", framerStatus);
// typical value: 0x3E
HW_PRINT("HW:: OrxFramerStatus = 0x%x\n", obsFramerStatus);
// typical value: 0x28
HW_PRINT("HW:: DeframerStatus = 0x%x\n", deframerStatus);
}
HW_PRINT("HW:: All configuration done!\n");
return ADIERR_OK;
}
// this function is NOT safe
// int HW_ad9371DynamicCfgInit(void)
//{
// int Status;
//
// Status = HW_setupIntrSystem(INTC_DEVICE_ID, &Intc);
// if (Status != XST_SUCCESS) {
// HW_PRINT("HW: HW_setupIntrSystem() failed!\n");
// return XST_FAILURE;
// }
//
// Status = XGpio_Initialize(&GpioFreqCtrl, FREQ_CTRL_DEVICE_ID);
// Status |= XGpio_Initialize(&GpioGainCtrl, GAIN_CTRL_DEVICE_ID);
// Status |= XGpio_Initialize(&GpioAttnCtrl, ATTN_CTRL_DEVICE_ID);
// if (Status != XST_SUCCESS) {
// HW_PRINT("HW: GPIO init failed!\n");
// return XST_FAILURE;
// }
//
// /* Set the direction for all signals as inputs. */
// XGpio_SetDataDirection(&GpioFreqCtrl, AXI_GPIO_BANK_1, 0xFFFFFFFF);
// XGpio_SetDataDirection(&GpioFreqCtrl, AXI_GPIO_BANK_2, 0xFFFFFFFF);
//
// XGpio_SetDataDirection(&GpioGainCtrl, AXI_GPIO_BANK_1, 0xFFFFFFFF);
// XGpio_SetDataDirection(&GpioGainCtrl, AXI_GPIO_BANK_2, 0xFFFFFFFF);
//
// XGpio_SetDataDirection(&GpioAttnCtrl, AXI_GPIO_BANK_1, 0xFFFFFFFF);
// XGpio_SetDataDirection(&GpioAttnCtrl, AXI_GPIO_BANK_2, 0xFFFFFFFF);
//
// Status = HW_connectIntr(&Intc, FREQ_CTRL_INTR_ID,
// (Xil_InterruptHandler)FreqIntrHandler, &GpioFreqCtrl, 0xA0, 0x3);
// Status |= HW_connectIntr(&Intc, GAIN_CTRL_INTR_ID,
// (Xil_InterruptHandler)GainIntrHandler, &GpioGainCtrl, 0xA0, 0x3);
// Status |= HW_connectIntr(&Intc, ATTN_CTRL_INTR_ID,
// (Xil_InterruptHandler)AttnIntrHandler, &GpioAttnCtrl, 0xA0, 0x3);
//
// XGpio_InterruptEnable(&GpioFreqCtrl, XGPIO_IR_MASK);
// XGpio_InterruptGlobalEnable(&GpioFreqCtrl);
//
// XGpio_InterruptEnable(&GpioGainCtrl, XGPIO_IR_MASK);
// XGpio_InterruptGlobalEnable(&GpioGainCtrl);
//
// XGpio_InterruptEnable(&GpioAttnCtrl, XGPIO_IR_MASK);
// XGpio_InterruptGlobalEnable(&GpioAttnCtrl);
//
// return XST_SUCCESS;
//}
/*****************************************************************************/
/*
*
* This function setups the interrupt system.
*
* @param DeviceId is the unique identifier for a GIC device.
* @param GicPtr is a pointer to the instance of the INTC.
*
* @return
* - XST_SUCCESS if successful,
* - XST_FAILURE.if not succesful
*
* @note None.
*
******************************************************************************/
int HW_setupIntrSystem(u16 DeviceId, XScuGic *GicPtr)
{
int Status;
XScuGic_Config *CfgPtr;
/*
* Initialize the interrupt controller driver so that it is ready to
* use.
*/
CfgPtr = XScuGic_LookupConfig(DeviceId);
if (!CfgPtr)
{
HW_PRINT("No interrupt config found for %d\n", DeviceId);
return XST_FAILURE;
}
Status = XScuGic_CfgInitialize(GicPtr, CfgPtr, CfgPtr->CpuBaseAddress);
if (Status != XST_SUCCESS)
{
HW_PRINT("No interrupt config found for %d\n", DeviceId);
return XST_FAILURE;
}
Xil_ExceptionInit();
Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT,
(Xil_ExceptionHandler)XScuGic_InterruptHandler,
(void *)GicPtr);
Xil_ExceptionEnable();
return XST_SUCCESS;
}
int HW_connectIntr(XScuGic *GicPtr, u32 IntrId, Xil_InterruptHandler Handler,
void *CallBackRef, u8 Priority, u8 Trigger)
{
int Status;
// Register interrupt handler
Status = XScuGic_Connect(GicPtr, IntrId, (Xil_InterruptHandler)Handler,
CallBackRef);
if (Status != XST_SUCCESS)
{
return XST_FAILURE;
}
XScuGic_SetPriorityTriggerType(GicPtr, IntrId, Priority, Trigger);
XScuGic_Enable(GicPtr, IntrId);
return XST_SUCCESS;
}
int HW_adiCfgProfileInit(void)
{
if (!ad9528Init)
{
HW_PRINT("Cannot find ad9528 configuration profile with name 'ad9528Init'!");
return ADIERR_FAILED;
}
ad9528Init->spiSettings->chipSelectIndex = AD9528_CS;
mykDevice.spiSettings->chipSelectIndex = AD9371_CS;
mykDevice.rx->framer->serializerLanesEnabled = 0x03;
mykDevice.rx->framer->serializerLaneCrossbar = 0xE4;
mykDevice.obsRx->framer->serializerLanesEnabled = 0x04;
mykDevice.tx->deframer->deserializerLanesEnabled = 0x03;
mykDevice.tx->deframer->deserializerLaneCrossbar = 0xE4;
return ADIERR_OK;
}
int HW_9528Config(ad9528Device_t *clockAD9528_device)
{
ADI_ERR error;
/**************************************************************************/
/***** System Clocks Initialization Initialization Sequence *****/
/**************************************************************************/
/* Perform a hard reset on the AD9528 DUT */
error = AD9528_resetDevice(clockAD9528_device);
if (error != ADIERR_OK)
{
HW_PRINT("AD9528_resetDevice() failed\n");
return ADIERR_FAILED;
}
error = AD9528_initDeviceDataStruct(clockAD9528_device,
clockAD9528_device->pll1Settings->vcxo_Frequency_Hz,
clockAD9528_device->pll1Settings->refA_Frequency_Hz,
clockAD9528_device->outputSettings->outFrequency_Hz[1]);
if (error != ADIERR_OK)
{
HW_PRINT("AD9528_initDeviceDataStruct() failed\n");
return ADIERR_FAILED;
}
/* Initialize the AD9528 by writing all SPI registers */
error = AD9528_initialize(clockAD9528_device);
if (error != ADIERR_OK)
{
HW_PRINT("WARNING: AD9528_initialize() issues.\n");
}
return ADIERR_OK;
}
int HW_9528GetLockStatus(ad9528Device_t *device, uint8_t *reg508)
{
ADI_ERR error;
error = CMB_SPIReadByte(device->spiSettings, AD9528_ADDR_STATUS_READBACK0, reg508);
if (error != ADIERR_OK)
{
HW_PRINT("HW_9528GetLockStatus failed.\n");
return ADIERR_FAILED;
}
return ADIERR_OK;
}
int HW_9371Config(ad9528Device_t *clockAD9528_device, mykonosDevice_t *mykDevice)
{
ADI_ERR error;
mykonosErr_t mykError;
const char *errorString;
uint8_t pllLockStatus;
uint8_t mcsStatus;
uint8_t arm_major;
uint8_t arm_minor;
uint8_t arm_release;
uint32_t initCalMask = TX_BB_FILTER | ADC_TUNER | TIA_3DB_CORNER | DC_OFFSET |
TX_ATTENUATION_DELAY | RX_GAIN_DELAY | FLASH_CAL |
PATH_DELAY | TX_LO_LEAKAGE_INTERNAL | TX_QEC_INIT |
LOOPBACK_RX_LO_DELAY | LOOPBACK_RX_RX_QEC_INIT |
RX_LO_DELAY | RX_QEC_INIT;
uint8_t errorFlag = 0;
uint8_t errorCode = 0;
uint32_t initCalsCompleted;
uint32_t trackingCalMask = TRACK_ORX1_QEC | TRACK_ORX2_QEC | TRACK_RX1_QEC |
TRACK_RX2_QEC | TRACK_TX1_QEC | TRACK_TX2_QEC;
/* Allocating memory for the errorString */
errorString = NULL;
/*************************************************************************/
/***** Mykonos Initialization Sequence *****/
/*************************************************************************/
/* Perform a hard reset on the MYKONOS DUT (Toggle RESETB pin on device) */
if ((mykError = MYKONOS_resetDevice(mykDevice)) != MYKONOS_ERR_OK)
{
errorString = getMykonosErrorMessage(mykError);
goto error_11;
}
if ((mykError = MYKONOS_initialize(mykDevice)) != MYKONOS_ERR_OK)
{
errorString = getMykonosErrorMessage(mykError);
goto error_11;
}
/*************************************************************************/
/***** Mykonos CLKPLL Status Check *****/
/*************************************************************************/
if ((mykError = MYKONOS_checkPllsLockStatus(mykDevice,
&pllLockStatus)) != MYKONOS_ERR_OK)
{
errorString = getMykonosErrorMessage(mykError);
goto error_11;
}
/*************************************************************************/
/***** Mykonos Perform MultiChip Sync *****/
/*************************************************************************/
if ((mykError = MYKONOS_enableMultichipSync(mykDevice, 1,
&mcsStatus)) != MYKONOS_ERR_OK)
{
errorString = getMykonosErrorMessage(mykError);
goto error_11;
}
/* Minimum 3 SYSREF pulses from Clock Device has to be produced for MulticChip Sync */
AD9528_requestSysref(clockAD9528_device, 1);
mdelay(1);
AD9528_requestSysref(clockAD9528_device, 1);
mdelay(1);
AD9528_requestSysref(clockAD9528_device, 1);
mdelay(1);
AD9528_requestSysref(clockAD9528_device, 1);
mdelay(1);
/*************************************************************************/
/***** Mykonos Verify MultiChip Sync *****/
/*************************************************************************/
if ((mykError = MYKONOS_enableMultichipSync(mykDevice, 0,
&mcsStatus)) != MYKONOS_ERR_OK)
{
errorString = getMykonosErrorMessage(mykError);
goto error_11;
}
if ((mcsStatus & 0x0B) == 0x0B)
HW_PRINT("MCS successful\n");
else
HW_PRINT("MCS failed\n");
/*************************************************************************/
/***** Mykonos Load ARM file *****/
/*************************************************************************/
if (pllLockStatus & 0x01)
{
HW_PRINT("CLKPLL locked\n");
if ((mykError = MYKONOS_initArm(mykDevice)) != MYKONOS_ERR_OK)
{
errorString = getMykonosErrorMessage(mykError);
goto error_11;
}
if ((mykError = MYKONOS_loadArmFromBinary(mykDevice,
&firmware_Mykonos_M3_bin[0], firmware_Mykonos_M3_bin_len)) != MYKONOS_ERR_OK)
{
errorString = getMykonosErrorMessage(mykError);
goto error_11;
}
}
else
{
HW_PRINT("CLKPLL not locked (0x%x)\n", pllLockStatus);
error = ADIERR_FAILED;
goto error_2;
}
/* Read back the version of the ARM binary loaded into the Mykonos ARM memory */
if ((mykError = MYKONOS_getArmVersion(mykDevice, &arm_major, &arm_minor,
&arm_release, NULL)) == MYKONOS_ERR_OK)
HW_PRINT("AD9371 ARM version %d.%d.%d\n", arm_major, arm_minor, arm_release);
/*************************************************************************/
/***** Mykonos Set RF PLL Frequencies *****/
/*************************************************************************/
if ((mykError = MYKONOS_setRfPllFrequency(mykDevice, RX_PLL,
mykDevice->rx->rxPllLoFrequency_Hz)) != MYKONOS_ERR_OK)
{
errorString = getMykonosErrorMessage(mykError);
goto error_11;
}
if ((mykError = MYKONOS_setRfPllFrequency(mykDevice, TX_PLL,
mykDevice->tx->txPllLoFrequency_Hz)) != MYKONOS_ERR_OK)
{
errorString = getMykonosErrorMessage(mykError);
goto error_11;
}
if ((mykError = MYKONOS_setRfPllFrequency(mykDevice, SNIFFER_PLL,
mykDevice->obsRx->snifferPllLoFrequency_Hz)) != MYKONOS_ERR_OK)
{
errorString = getMykonosErrorMessage(mykError);
goto error_11;
}
/* Wait 200ms for PLLs to lock */
mdelay(200);
if ((mykError = MYKONOS_checkPllsLockStatus(mykDevice,
&pllLockStatus)) != MYKONOS_ERR_OK)
{
errorString = getMykonosErrorMessage(mykError);
goto error_11;
}
if ((pllLockStatus & 0x0F) == 0x0F)
HW_PRINT("PLLs locked\n");
else
{
HW_PRINT("PLLs not locked (0x%x)\n", pllLockStatus);
error = ADIERR_FAILED;
goto error_2;
}
// /*************************************************************************/
// /***** Mykonos Set GPIOs *****/
// /*************************************************************************/
//
// if ((mykGpioErr = MYKONOS_setRx1GainCtrlPin(mykDevice, 0, 0, 0, 0,
// 0)) != MYKONOS_ERR_GPIO_OK) {
// errorString = getGpioMykonosErrorMessage(mykGpioErr);
// goto error_11;
// }
//
// if ((mykGpioErr = MYKONOS_setRx2GainCtrlPin(mykDevice, 0, 0, 0, 0,
// 0)) != MYKONOS_ERR_GPIO_OK) {
// errorString = getGpioMykonosErrorMessage(mykGpioErr);
// goto error_11;
// }
//
// if ((mykGpioErr = MYKONOS_setTx1AttenCtrlPin(mykDevice, 0, 0, 0, 0,
// 0)) != MYKONOS_ERR_GPIO_OK) {
// errorString = getGpioMykonosErrorMessage(mykGpioErr);
// goto error_11;
// }
//
// if ((mykGpioErr = MYKONOS_setTx2AttenCtrlPin(mykDevice, 0, 0, 0,
// 0)) != MYKONOS_ERR_GPIO_OK) {
// errorString = getGpioMykonosErrorMessage(mykGpioErr);
// goto error_11;
// }
//
// if ((mykGpioErr = MYKONOS_setupGpio(mykDevice)) != MYKONOS_ERR_GPIO_OK) {
// errorString = getGpioMykonosErrorMessage(mykGpioErr);
// goto error_11;
// }
//
// /*************************************************************************/
// /***** Mykonos Set manual gains values *****/
// /*************************************************************************/
//
// if ((mykError = MYKONOS_setRx1ManualGain(mykDevice, 255)) != MYKONOS_ERR_OK) {
// errorString = getMykonosErrorMessage(mykError);
// goto error_11;
// }
//
// if ((mykError = MYKONOS_setRx2ManualGain(mykDevice, 255)) != MYKONOS_ERR_OK) {
// errorString = getMykonosErrorMessage(mykError);
// goto error_11;
// }
//
// if ((mykError = MYKONOS_setObsRxManualGain(mykDevice, OBS_RX1_TXLO,
// 255)) != MYKONOS_ERR_OK) {
// errorString = getMykonosErrorMessage(mykError);
// goto error_11;
// }
//
// if ((mykError = MYKONOS_setObsRxManualGain(mykDevice, OBS_RX2_TXLO,
// 255)) != MYKONOS_ERR_OK) {
// errorString = getMykonosErrorMessage(mykError);
// goto error_11;
// }
//
// if ((mykError = MYKONOS_setObsRxManualGain(mykDevice, OBS_SNIFFER_A,
// 255)) != MYKONOS_ERR_OK) {
// errorString = getMykonosErrorMessage(mykError);
// goto error_11;
// }
//
// if ((mykError = MYKONOS_setObsRxManualGain(mykDevice, OBS_SNIFFER_B,
// 255)) != MYKONOS_ERR_OK) {
// errorString = getMykonosErrorMessage(mykError);
// goto error_11;
// }
//
// if ((mykError = MYKONOS_setObsRxManualGain(mykDevice, OBS_SNIFFER_C,
// 255)) != MYKONOS_ERR_OK) {
// errorString = getMykonosErrorMessage(mykError);
// goto error_11;
// }
//
// /*************************************************************************/
// /***** Mykonos Initialize attenuations *****/
// /*************************************************************************/
//
// mykError = MYKONOS_setTx1Attenuation(mykDevice, 10000);
// if (mykError != MYKONOS_ERR_OK) {
// errorString = getMykonosErrorMessage(mykError);
// goto error_11;
// }
//
// mykError = MYKONOS_setTx2Attenuation(mykDevice, 10000);
// if (mykError != MYKONOS_ERR_OK) {
// errorString = getMykonosErrorMessage(mykError);
// goto error_11;
// }
/*************************************************************************/
/***** Mykonos ARM Initialization Calibrations *****/
/*************************************************************************/
if ((mykError = MYKONOS_runInitCals(mykDevice,
(initCalMask & ~TX_LO_LEAKAGE_EXTERNAL))) != MYKONOS_ERR_OK)
{
errorString = getMykonosErrorMessage(mykError);
goto error_11;
}
if ((mykError = MYKONOS_waitInitCals(mykDevice, 60000, &errorFlag,
&errorCode)) != MYKONOS_ERR_OK)
{
errorString = getMykonosErrorMessage(mykError);
goto error_11;
}
if ((errorFlag != 0) || (errorCode != 0))
{
/*** < Info: abort init cals > ***/
if ((mykError = MYKONOS_abortInitCals(mykDevice,
&initCalsCompleted)) != MYKONOS_ERR_OK)
{
errorString = getMykonosErrorMessage(mykError);
goto error_11;
}
if (initCalsCompleted)
HW_PRINT("Completed calibrations: %x\n", (unsigned int)initCalsCompleted);
}
else
HW_PRINT("Calibrations completed successfully\n");
/*************************************************************************/
/***** Mykonos ARM Initialization External LOL Calibrations with PA *****/
/*************************************************************************/
/* Please ensure PA is enabled operational at this time */
if (initCalMask & TX_LO_LEAKAGE_EXTERNAL)
{
if ((mykError = MYKONOS_runInitCals(mykDevice,
TX_LO_LEAKAGE_EXTERNAL)) != MYKONOS_ERR_OK)
{
errorString = getMykonosErrorMessage(mykError);
goto error_11;
}
if ((mykError = MYKONOS_waitInitCals(mykDevice, 60000, &errorFlag,
&errorCode)) != MYKONOS_ERR_OK)
{
errorString = getMykonosErrorMessage(mykError);
goto error_11;
}
if ((errorFlag != 0) || (errorCode != 0))
{
/*** < Info: abort init cals > ***/
if ((mykError = MYKONOS_abortInitCals(mykDevice,
&initCalsCompleted)) != MYKONOS_ERR_OK)
{
errorString = getMykonosErrorMessage(mykError);
goto error_11;
}
}
else
HW_PRINT("External LOL Calibrations completed successfully\n");
}
/*************************************************************************/
/***** SYSTEM JESD bring up procedure *****/
/*************************************************************************/
if ((mykError = MYKONOS_enableSysrefToRxFramer(mykDevice,
1)) != MYKONOS_ERR_OK)
{
errorString = getMykonosErrorMessage(mykError);
goto error_11;
}
/*** < Info: Mykonos is waiting for sysref in order to start
* transmitting CGS from the RxFramer> ***/
if ((mykError = MYKONOS_enableSysrefToObsRxFramer(mykDevice,
1)) != MYKONOS_ERR_OK)
{
errorString = getMykonosErrorMessage(mykError);
goto error_11;
}
/*** < Info: Mykonos is waiting for sysref in order to start
* transmitting CGS from the ObsRxFramer> ***/
if ((mykError = MYKONOS_enableSysrefToDeframer(mykDevice,
0)) != MYKONOS_ERR_OK)
{
errorString = getMykonosErrorMessage(mykError);
goto error_11;
}
if ((mykError = MYKONOS_resetDeframer(mykDevice)) != MYKONOS_ERR_OK)
{
errorString = getMykonosErrorMessage(mykError);
goto error_11;
}
if ((mykError = MYKONOS_enableSysrefToDeframer(mykDevice, 1)) != MYKONOS_ERR_OK)
{
errorString = getMykonosErrorMessage(mykError);
goto error_11;
}
/*************************************************************************/
/***** Enable SYSREF to Mykonos and BBIC *****/
/*************************************************************************/
/* Request a SYSREF from the AD9528 */
AD9528_requestSysref(clockAD9528_device, 1);
mdelay(1);
/*** < Info: Mykonos is actively transmitting CGS from the RxFramer> ***/
/*** < Info: Mykonos is actively transmitting CGS from the ObsRxFramer> ***/
/* Request two SYSREFs from the AD9528 */
AD9528_requestSysref(clockAD9528_device, 1);
mdelay(1);
AD9528_requestSysref(clockAD9528_device, 1);
mdelay(5);
/*************************************************************************/
/***** Mykonos enable tracking calibrations *****/
/*************************************************************************/
if ((mykError = MYKONOS_enableTrackingCals(mykDevice,
trackingCalMask)) != MYKONOS_ERR_OK)
{
errorString = getMykonosErrorMessage(mykError);
goto error_11;
}
/*** < Info: Allow Rx1/2 QEC tracking and Tx1/2 QEC tracking to run when in the radioOn state
* Tx calibrations will only run if radioOn and the obsRx path is set to OBS_INTERNAL_CALS > ***/
/*** < Info: Function to turn radio on, Enables transmitters and receivers
* that were setup during MYKONOS_initialize() > ***/
if ((mykError = MYKONOS_radioOn(mykDevice)) != MYKONOS_ERR_OK)
{
errorString = getMykonosErrorMessage(mykError);
goto error_11;
}
/*** < Info: Allow TxQEC to run when User: is not actively using ORx receive path > ***/
if ((mykError = MYKONOS_setObsRxPathSource(mykDevice,
OBS_RXOFF)) != MYKONOS_ERR_OK)
{
errorString = getMykonosErrorMessage(mykError);
goto error_11;
}
if ((mykError = MYKONOS_setObsRxPathSource(mykDevice,
OBS_INTERNALCALS)) != MYKONOS_ERR_OK)
{
errorString = getMykonosErrorMessage(mykError);
goto error_11;
}
mdelay(1000);
if ((mykError = MYKONOS_setObsRxPathSource(mykDevice,
OBS_RX1_SNIFFERLO)) != MYKONOS_ERR_OK)
{
errorString = getMykonosErrorMessage(mykError);
goto error_11;
}
Xil_DCacheInvalidateRange(DDR_MEM_BASEADDR + 0x800000, 16384 * 8);
HW_PRINT("Done\n");
return 0;
error_11:
HW_PRINT("%s", errorString);
error_2:
// axi_clkgen_remove(rx_clkgen);
return FAILURE;
}
int HW_9371CheckJesdStatus(mykonosDevice_t *mykDevice, uint8_t *framerStatus,
uint8_t *obsFramerStatus, uint8_t *deframerStatus)
{
mykonosErr_t mykError;
const char *errorString;
/* Allocating memory for the errorString */
errorString = NULL;
/*************************************************************************/
/***** Check Mykonos Framer Status *****/
/*************************************************************************/
if ((mykError = MYKONOS_readRxFramerStatus(mykDevice,
framerStatus)) != MYKONOS_ERR_OK)
{
errorString = getMykonosErrorMessage(mykError);
return ADIERR_FAILED;
}
else
{
// typical value: 0x3E
}
if ((mykError = MYKONOS_readOrxFramerStatus(mykDevice,
obsFramerStatus)) != MYKONOS_ERR_OK)
{
errorString = getMykonosErrorMessage(mykError);
return ADIERR_FAILED;
}
else
{
// typical value: 0x3E
}
/*************************************************************************/
/***** Check Mykonos Deframer Status *****/
/*************************************************************************/
if ((mykError = MYKONOS_readDeframerStatus(mykDevice,
deframerStatus)) != MYKONOS_ERR_OK)
{
errorString = getMykonosErrorMessage(mykError);
return ADIERR_FAILED;
}
else
{
// typical value: 0x28
}
return ADIERR_OK;
}
int HW_9371SmallFrequencyChange(mykonosDevice_t *mykDevice, uint64_t freq_Hz)
{
mykonosErr_t mykError = MYKONOS_ERR_OK;
uint8_t pllLockStatus = 0;
/*
* Move the device into the radio off state.
*/
if ((mykError = MYKONOS_radioOff(mykDevice)) != MYKONOS_ERR_OK)
{
HW_PRINT("Turn radio off failed!\n\r");
return ADIERR_FAILED;
}
/*
* Program the new local oscillator (LO) frequency. Check if PLL is locked.
*/
if ((mykError = MYKONOS_setRfPllFrequency(mykDevice, TX_PLL,
freq_Hz)) != MYKONOS_ERR_OK)
{
HW_PRINT("Set TX PLL failed!\n\r");
return ADIERR_FAILED;
}
mykError = MYKONOS_checkPllsLockStatus(mykDevice, &pllLockStatus);
if ((pllLockStatus & 0x07) != 0x07)
{
/*** < Info: Clock, Rx and Tx PLLs not locked > ***/
HW_PRINT("Not all PLLs locked, lock status: 0x%02x\n", pllLockStatus);
}
/*
* Reset the external channel.
*/
// If((mykError = MYKONOS_resetExtTxLolChannel(mykDevice, TX1_TX2))
// != MYKONOS_ERR_OK) ; //where TX1_TX2 is part of the enum mykonosTxChannels_t
// {
// HW_PRINT("Reset external channel FAILED!");
// }
/*
* Move the device back into the radio on state.
*/
if ((mykError = MYKONOS_radioOn(mykDevice)) != MYKONOS_ERR_OK)
{
HW_PRINT("Turn radio on failed!\n\r");
return ADIERR_FAILED;
}
/*
* Reenable tracking calibrations.
*/
// If((mykError = MYKONOS_MYKONOS_setObsRxPathSource(mykDevice, OBS_INTERNALCALS))
// != MYKONOS_ERR_OK) ; //where TX1_TX2 is part of the enum mykonosTxChannels_t
// {
// HW_PRINT("Reenable tracking calibrations FAILED!");
// }
return ADIERR_OK;
}
int HW_9371LargeFrequencyChange(mykonosDevice_t *mykDevice, uint64_t freq_Hz)
{
mykonosErr_t mykError = MYKONOS_ERR_OK;
uint8_t pllLockStatus = 0;
uint8_t errorFlag = 0;
uint8_t errorCode = 0;
uint32_t initCalsCompleted = 0;
uint16_t errorWord = 0;
uint16_t statusWord = 0;
uint8_t status = 0;
mykonosInitCalStatus_t initCalStatus = {0};
/*
* Move the device into the radio off state.
*/
if ((mykError = MYKONOS_radioOff(mykDevice)) != MYKONOS_ERR_OK)
{
HW_PRINT("Turn radio off failed!\n\r");
return ADIERR_FAILED;
}
/*
* Program the new local oscillator (LO) frequency. Check if PLL is locked.
*/
if ((mykError = MYKONOS_setRfPllFrequency(mykDevice, TX_PLL,
freq_Hz)) != MYKONOS_ERR_OK)
{
HW_PRINT("Set TX PLL failed!\n\r");
return ADIERR_FAILED;
}
mykError = MYKONOS_checkPllsLockStatus(mykDevice, &pllLockStatus);
if ((pllLockStatus & 0x07) != 0x07)
{
/*** < Info: Clock, Rx and Tx PLLs not locked > ***/
HW_PRINT("Not all PLLs locked, lock status: 0x%02x\n", pllLockStatus);
}
/*
* Rerun the initialization calibrations.
*/
uint32_t initCalMask = TX_QEC_INIT | LOOPBACK_RX_LO_DELAY |
LOOPBACK_RX_RX_QEC_INIT | RX_LO_DELAY | RX_QEC_INIT;
if ((mykError = MYKONOS_runInitCals(mykDevice, initCalMask)) != MYKONOS_ERR_OK)
{
HW_PRINT("Rerun the initialization calibrations FAILED!");
return ADIERR_FAILED;
}
if ((mykError = MYKONOS_waitInitCals(mykDevice, 60000, &errorFlag,
&errorCode)) != MYKONOS_ERR_OK)
{
HW_PRINT("Initialize calibration TIME OUT!");
return ADIERR_FAILED;
}
if ((errorFlag != 0) || (errorCode != 0))
{
HW_PRINT("initial cals error!\n\r");
if ((mykError = MYKONOS_getInitCalStatus(mykDevice, &initCalStatus)) != MYKONOS_ERR_OK)
{
/*** < User log error return value to debug why init failed > ***/
}
// abort init calibrations
if ((mykError = MYKONOS_abortInitCals(mykDevice, &initCalsCompleted)) != MYKONOS_ERR_OK)
{
/*** < User log error return value to debug why init failed > ***/
}
if (initCalsCompleted)
{
/*** < which calls had completed, per the mask > ***/
}
if ((mykError = MYKONOS_readArmCmdStatus(mykDevice, &errorWord,
&statusWord)) != MYKONOS_ERR_OK)
{
/*** < User log error return value to debug why init failed > ***/
}
if ((mykError = MYKONOS_readArmCmdStatusByte(mykDevice, 2, &status)) != MYKONOS_ERR_OK)
{
}
if (status != 0)
{
/*** < Arm Mailbox Status Error errorWord > ***/
/*** < Pending Flag per opcode statusWord, this follows the mask > ***/
}
}
/*
* Move the device back into the radio on state.
*/
if ((mykError = MYKONOS_radioOn(mykDevice)) != MYKONOS_ERR_OK)
{
HW_PRINT("Turn radio on failed!\n\r");
return ADIERR_FAILED;
}
return ADIERR_OK;
}
// void FreqIntrHandler(void *CallbackRef)
// {
// XGpio *GpioPtr = (XGpio *)CallbackRef;
// uint8_t IntrStatus;
// uint32_t NewFreqHz;
// IntrStatus = XGpio_InterruptGetStatus(GpioPtr);
// if (IntrStatus & XGPIO_IR_CH1_MASK)
// {
// /* Clear the Interrupt */
// XGpio_InterruptClear(GpioPtr, XGPIO_IR_CH1_MASK);
// NewFreqHz = XGpio_DiscreteRead(GpioPtr, AXI_GPIO_BANK_1);
// if (NewFreqHz != mykDevice.tx->txPllLoFrequency_Hz)
// {
// if (NewFreqHz > 300000000 && NewFreqHz < 6000000000)
// {
// if (abs(NewFreqHz - mykDevice.tx->txPllLoFrequency_Hz) <= 100000000)
// {
// HW_9371SmallFrequencyChange(&mykDevice, NewFreqHz);
// }
// else
// {
// HW_9371LargeFrequencyChange(&mykDevice, NewFreqHz);
// }
// mykDevice.tx->txPllLoFrequency_Hz = NewFreqHz;
// HW_PRINT("New Tx frequency set to %d Hz!\n", NewFreqHz);
// }
// else
// {
// HW_PRINT("The desired Tx Frequency is out of range(300 ~ 6000 MHz)!\n");
// }
// }
// }
// if (IntrStatus & XGPIO_IR_CH2_MASK)
// {
// /* Clear the Interrupt */
// XGpio_InterruptClear(GpioPtr, XGPIO_IR_CH2_MASK);
// NewFreqHz = XGpio_DiscreteRead(GpioPtr, AXI_GPIO_BANK_2);
// if (NewFreqHz != mykDevice.rx->rxPllLoFrequency_Hz)
// {
// if (NewFreqHz > 300000000 && NewFreqHz < 6000000000)
// {
// if (abs(NewFreqHz - mykDevice.rx->rxPllLoFrequency_Hz) <= 100000000)
// {
// HW_9371SmallFrequencyChange(&mykDevice, NewFreqHz);
// }
// else
// {
// HW_9371LargeFrequencyChange(&mykDevice, NewFreqHz);
// }
// mykDevice.rx->rxPllLoFrequency_Hz = NewFreqHz;
// HW_PRINT("New Rx frequency set to %d Hz!\n", NewFreqHz);
// }
// else
// {
// HW_PRINT("The desired Rx Frequency is out of range(300 ~ 6000 MHz)!\n");
// }
// }
// }
// }
// void GainIntrHandler(void *CallbackRef)
// {
// XGpio *GpioPtr = (XGpio *)CallbackRef;
// uint8_t IntrStatus;
// uint32_t NewRxGain;
// IntrStatus = XGpio_InterruptGetStatus(GpioPtr);
// if (IntrStatus & XGPIO_IR_CH1_MASK)
// {
// /* Clear the Interrupt */
// XGpio_InterruptClear(GpioPtr, XGPIO_IR_CH1_MASK);
// NewRxGain = XGpio_DiscreteRead(GpioPtr, AXI_GPIO_BANK_1);
// if (NewRxGain != mykDevice.rx->rxGainCtrl->rx1GainIndex)
// {
// if ((NewRxGain >= 195) && (NewRxGain <= 255))
// {
// MYKONOS_setRx1ManualGain(&mykDevice, NewRxGain);
// mykDevice.rx->rxGainCtrl->rx1GainIndex = NewRxGain;
// char buf[BUFSIZ];
// sHW_PRINT(buf, "%u", NewRxGain);
// HW_PRINT("New Rx1 gain index set to %s!\n", buf);
// }
// else
// {
// HW_PRINT("The desired Rx1 gain index is out of range(195 ~ 255), 0.5dB per stage!\n");
// }
// }
// }
// if (IntrStatus & XGPIO_IR_CH2_MASK)
// {
// /* Clear the Interrupt */
// XGpio_InterruptClear(GpioPtr, XGPIO_IR_CH2_MASK);
// NewRxGain = XGpio_DiscreteRead(GpioPtr, AXI_GPIO_BANK_2);
// if (NewRxGain != mykDevice.rx->rxGainCtrl->rx2GainIndex)
// {
// if ((NewRxGain >= 195) && (NewRxGain <= 255))
// {
// MYKONOS_setRx2ManualGain(&mykDevice, NewRxGain);
// mykDevice.rx->rxGainCtrl->rx2GainIndex = NewRxGain;
// char buf[BUFSIZ];
// sHW_PRINT(buf, "%u", NewRxGain);
// HW_PRINT("New Rx2 gain index set to %s!\n", buf);
// }
// else
// {
// HW_PRINT("The desired Rx2 gain index is out of range(195 ~ 255), 0.5dB per stage!\n");
// }
// }
// }
// }
// void AttnIntrHandler(void *CallbackRef)
// {
// XGpio *GpioPtr = (XGpio *)CallbackRef;
// uint8_t IntrStatus;
// uint32_t NewTxAttn;
// IntrStatus = XGpio_InterruptGetStatus(GpioPtr);
// if (IntrStatus & XGPIO_IR_CH1_MASK)
// {
// /* Clear the Interrupt */
// XGpio_InterruptClear(GpioPtr, XGPIO_IR_CH1_MASK);
// NewTxAttn = XGpio_DiscreteRead(GpioPtr, AXI_GPIO_BANK_1);
// if (NewTxAttn != mykDevice.tx->tx1Atten_mdB)
// {
// if ((NewTxAttn >= 0) && (NewTxAttn <= 41950))
// {
// MYKONOS_setTx1Attenuation(&mykDevice, NewTxAttn);
// mykDevice.tx->tx1Atten_mdB = NewTxAttn;
// char buf[BUFSIZ];
// sHW_PRINT(buf, "%u", NewTxAttn);
// HW_PRINT("New Tx1 attenuation set to %s dBm!\n", buf);
// }
// else
// {
// HW_PRINT("The desired Tx1 attenuation is out of range(0 ~ 41950 dBm), 50 dBm step!\n");
// }
// }
// }
// if (IntrStatus & XGPIO_IR_CH2_MASK)
// {
// /* Clear the Interrupt */
// XGpio_InterruptClear(GpioPtr, XGPIO_IR_CH2_MASK);
// NewTxAttn = XGpio_DiscreteRead(GpioPtr, AXI_GPIO_BANK_2);
// if (NewTxAttn != mykDevice.tx->tx2Atten_mdB)
// {
// if ((NewTxAttn >= 0) && (NewTxAttn <= 41950))
// {
// MYKONOS_setTx2Attenuation(&mykDevice, NewTxAttn);
// mykDevice.tx->tx2Atten_mdB = NewTxAttn;
// char buf[BUFSIZ];
// sHW_PRINT(buf, "%u", NewTxAttn);
// HW_PRINT("New Tx2 attenuation set to %s dBm!\n", buf);
// }
// else
// {
// HW_PRINT("The desired Tx2 attenuation is out of range(0 ~ 41950 dBm), 50 dBm step!\n");
// }
// }
// }
// }
Reference in New Issue View Git Blame Copy Permalink