/**
*
* This function does a selftest on the IIC device and XIic driver as an
* example.
*
* @param DeviceId is the XPAR_<IIC_instance>_DEVICE_ID value from
* xparameters.h.
*
* @return XST_SUCCESS if successful, XST_FAILURE if unsuccessful.
*
* @note None.
*
****************************************************************************/
int IicSelfTestExample(u16 DeviceId)
{
int Status;
XIic_Config *ConfigPtr; /* Pointer to configuration data */
/*
* Initialize the IIC driver so that it is ready to use.
*/
ConfigPtr = XIic_LookupConfig(DeviceId);
if (ConfigPtr == NULL) {
return XST_FAILURE;
}
Status = XIic_CfgInitialize(&Iic, ConfigPtr, ConfigPtr->BaseAddress);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Perform a self-test to ensure that the hardware was built
* correctly.
*/
Status = XIic_SelfTest(&Iic);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
return XST_SUCCESS;
}
/**
* This function sets up the I2C controller and uses it to initialize the DP159.
*
* @param InstancePtr is a pointer to the XIic instance representing the
* I2C controller connected to the same I2C bus which the DP159 is
* is addressable from.
* @param DeviceId is the device ID of the I2C controller.
*
* @return
* - XST_SUCCESS if the I2C controller and the DP159 retimer have
* been successfully set up and initialized.
* - XST_FAILURE otherwise.
*
* @note None.
*
*******************************************************************************/
static u32 Dprx_Dp159Setup(XIic *InstancePtr, u16 DeviceId)
{
u32 Status;
XIic_Config *ConfigPtr;
ConfigPtr = XIic_LookupConfig(IIC_DEVICE_ID);
if (!ConfigPtr) {
return XST_FAILURE;
}
Status = XIic_CfgInitialize(InstancePtr, ConfigPtr,
ConfigPtr->BaseAddress);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
XIic_DynInit(InstancePtr->BaseAddress);
/* This is hardware system specific - it is up to the user to implement
* this function if needed. In some systems, a GPIO controller can reset
* the DP159. In other systems, the reset functionality may be
* accomplished using:
* void XVidC_Dp159Reset(XIic *InstancePtr, u8 Reset); */
Dprx_Dp159Reset();
/*******************/
Status = XVidC_Dp159Initialize(InstancePtr);
return Status;
}
/**
*
* Initializes a specific XIic instance. The initialization entails:
*
* - Check the device has an entry in the configuration table.
* - Initialize the driver to allow access to the device registers and
* initialize other subcomponents necessary for the operation of the device.
* - Default options to:
* - 7-bit slave addressing
* - Send messages as a slave device
* - Repeated start off
* - General call recognition disabled
* - Clear messageing and error statistics
*
* The XIic_Start() function must be called after this function before the device
* is ready to send and receive data on the IIC bus.
*
* Before XIic_Start() is called, the interrupt control must connect the ISR
* routine to the interrupt handler. This is done by the user, and not
* XIic_Start() to allow the user to use an interrupt controller of their choice.
*
* @param InstancePtr is a pointer to the XIic instance to be worked on.
* @param DeviceId is the unique id of the device controlled by this XIic
* instance. Passing in a device id associates the generic XIic
* instance to a specific device, as chosen by the caller or
* application developer.
*
* @return
* - XST_SUCCESS when successful
* - XST_DEVICE_NOT_FOUND indicates the given device id isn't found
* - XST_DEVICE_IS_STARTED indicates the device is started
* (i.e. interrupts enabled and messaging is possible).
* Must stop before re-initialization is allowed.
*
* @note None.
*
****************************************************************************/
int XIic_Initialize(XIic *InstancePtr, u16 DeviceId)
{
XIic_Config *ConfigPtr; /* Pointer to configuration data */
/*
* Asserts test the validity of selected input arguments.
*/
Xil_AssertNonvoid(InstancePtr != NULL);
/*
* Lookup the device configuration in the temporary CROM table. Use this
* configuration info down below when initializing this component.
*/
ConfigPtr = XIic_LookupConfig(DeviceId);
if (ConfigPtr == NULL) {
return XST_DEVICE_NOT_FOUND;
}
return XIic_CfgInitialize(InstancePtr, ConfigPtr,
ConfigPtr->BaseAddress);
}
/*
* Initialize Iic Structure
*/
int IicInit(XIic *IicInstPtr) {
XIic_Config *IicConfigPtr;
int Status;
/*
* Initialize the IIC device Instance.
*/
IicConfigPtr = XIic_LookupConfig(XPAR_IIC_0_DEVICE_ID);
if (IicConfigPtr == NULL) {
return XST_FAILURE;
}
/*
* Initialize Iic Instance with Config Ptr
*/
Status = XIic_CfgInitialize(IicInstPtr, IicConfigPtr, IicConfigPtr->BaseAddress);
if (Status != XST_SUCCESS) {
xil_printf("Error: XIic_Initialize FAILED\n\r");
return XST_FAILURE;
}
return XST_SUCCESS;
}
/**
* The function reads the temperature of the IIC temperature sensor on the
* IIC bus. It initializes the IIC device driver and sets it up to communicate
* with the temperature sensor. This function does contain a loop that polls
* for completion of the IIC processing such that it may not return if
* interrupts or the hardware are not working.
*
* @param IicDeviceId is the XPAR_<IIC_instance>_DEVICE_ID value from
* xparameters.h for the IIC Device
* @param TempSensorAddress is the address of the Temperature Sensor device
* on the IIC bus
* @param TemperaturePtr is the data byte read from the temperature sensor
*
* @return XST_SUCCESS to indicate success, else XST_FAILURE to indicate
* a Failure.
*
* @note None.
*
*******************************************************************************/
int TempSensorExample(u16 IicDeviceId, u8 TempSensorAddress, u8 *TemperaturePtr)
{
int Status;
static int Initialized = FALSE;
XIic_Config *ConfigPtr; /* Pointer to configuration data */
if (!Initialized) {
Initialized = TRUE;
/*
* Initialize the IIC driver so that it is ready to use.
*/
ConfigPtr = XIic_LookupConfig(IicDeviceId);
if (ConfigPtr == NULL) {
return XST_FAILURE;
}
Status = XIic_CfgInitialize(&Iic, ConfigPtr,
ConfigPtr->BaseAddress);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Setup handler to process the asynchronous events which occur,
* the driver is only interrupt driven such that this must be
* done prior to starting the device.
*/
XIic_SetRecvHandler(&Iic, (void *)&HandlerInfo, RecvHandler);
XIic_SetStatusHandler(&Iic, (void *)&HandlerInfo,
StatusHandler);
/*
* Connect the ISR to the interrupt and enable interrupts.
*/
Status = SetupInterruptSystem(&Iic);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Start the IIC driver such that it is ready to send and
* receive messages on the IIC interface, set the address
* to send to which is the temperature sensor address
*/
XIic_Start(&Iic);
XIic_SetAddress(&Iic, XII_ADDR_TO_SEND_TYPE, TempSensorAddress);
}
/*
* Clear updated flags such that they can be polled to indicate
* when the handler information has changed asynchronously and
* initialize the status which will be returned to a default value
*/
HandlerInfo.EventStatusUpdated = FALSE;
HandlerInfo.RecvBytesUpdated = FALSE;
Status = XST_FAILURE;
/*
* Attempt to receive a byte of data from the temperature sensor
* on the IIC interface, ignore the return value since this example is
* a single master system such that the IIC bus should not ever be busy
*/
(void)XIic_MasterRecv(&Iic, TemperaturePtr, 1);
/*
* The message is being received from the temperature sensor,
* wait for it to complete by polling the information that is
* updated asynchronously by interrupt processing
*/
while(1) {
if(HandlerInfo.RecvBytesUpdated == TRUE) {
/*
* The device information has been updated for receive
* processing,if all bytes received (1), indicate
* success
*/
if (HandlerInfo.RemainingRecvBytes == 0) {
Status = XST_SUCCESS;
}
break;
}
/*
* Any event status which occurs indicates there was an error,
* so return unsuccessful, for this example there should be no
* status events since there is a single master on the bus
*/
if (HandlerInfo.EventStatusUpdated == TRUE) {
break;
}
}
return Status;
}
