/**
*
* 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);
}
int TMP3_IICInit(XIic *IicInstancePtr){
int Status;
Status = XIic_CfgInitialize(IicInstancePtr, &TMP3_Config, TMP3_Config.BaseAddress);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Start the IIC driver so that the device is enabled.
*/
XIic_Start(IicInstancePtr);
/*
* Disable Global interrupt to use polled mode operation
*/
XIic_IntrGlobalDisable(IicInstancePtr);
return XST_SUCCESS;
}
/*
* 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;
}
/** Shared device initialization code */
static int __devinit xilinx_iic_setup(
struct device *device,
struct device_node *node,
struct resource *r_mem,
struct resource *r_irq,
u32 ten_bit_addr,
u32 gpo_width) {
XIic_Config xiic_cfg;
struct xiic_data *dev;
char *scan_results;
int error;
/* Allocate the dev and zero it out. */
dev = kmalloc(sizeof(struct xiic_data), GFP_KERNEL);
if (!dev) {
dev_err(device, "Cannot allocate struct xiic_data\n");
error = -ENOMEM;
goto out2;
}
memset(dev, 0, sizeof(struct xiic_data));
dev_set_drvdata(device, dev);
dev->irq = r_irq->start;
/* initialize fields to satisfy i2c */
dev->index = 0;
init_completion(&dev->complete);
memset(&xiic_cfg, 0, sizeof(XIic_Config));
xiic_cfg.DeviceId = 0;
/* Change the addresses to be virtual; save the old ones to restore. */
dev->base = r_mem->start;
xiic_cfg.BaseAddress =
(u32) ioremap(r_mem->start, r_mem->end - r_mem->start + 1);
dev->remapped = 1;
down(&cfg_sem);
xiic_cfg.Has10BitAddr = (int)ten_bit_addr;
xiic_cfg.GpOutWidth = (u8)gpo_width;
/* Tell the Xilinx code to bring this IIC interface up. */
if (XIic_CfgInitialize(&dev->Iic, &xiic_cfg, xiic_cfg.BaseAddress) !=
XST_SUCCESS) {
up(&cfg_sem);
dev_err(device, "could not initialize device.\n");
error = -ENODEV;
goto out;
}
up(&cfg_sem);
XIic_SetRecvHandler(&dev->Iic, (void *)dev, RecvHandler);
XIic_SetSendHandler(&dev->Iic, (void *)dev, SendHandler);
XIic_SetStatusHandler(&dev->Iic, (void *)dev, StatusHandler);
/* Grab the IRQ */
error = request_irq(dev->irq, xiic_interrupt, 0, dev->adap.name, dev);
if (error) {
dev_err(device, "could not allocate interrupt %d.\n", dev->irq);
goto out;
}
dev->reqirq = 1;
if (XIic_Start(&dev->Iic) != XST_SUCCESS) {
dev_err(device, "could not start device\n");
error = -ENODEV;
goto out;
}
dev->started = 1;
/* Now tell the core I2C code about our new device. */
strcpy(dev->adap.name, "xilinx-iic");
dev->adap.dev.of_node = node;
dev->adap.algo = &xiic_algo;
dev->adap.algo_data = NULL;
dev->adap.timeout = XIIC_TIMEOUT;
dev->adap.retries = XIIC_RETRY;
error = i2c_add_adapter(&dev->adap);
if (error) {
dev_err(device, "could not add i2c adapter\n");
goto out;
}
dev->added = 1;
printk("%s #%d at 0x%08X mapped to 0x%08X, irq=%d\n",
dev->adap.name, dev->index,
dev->base, (unsigned int)dev->Iic.BaseAddress, dev->irq);
if (scan) {
scan_results = xilinx_iic_do_scan(dev);
if (scan_results) {
printk(scan_results);
kfree(scan_results);
}
}
of_i2c_register_devices(&dev->adap);
error = device_create_file(device, &dev_attr_scan);
out:
if (error)
xilinx_iic_remove(device);
out2:
return error;
}
static int __init xilinx_iic_probe(struct of_device *of_dev,
const struct of_device_id *match)
{
XIic_Config xiic_cfg;
struct xiic_data *dev;
char *scan_results;
struct resource mem;
struct device_node *dev_node = of_dev->node;
int error;
const u32 *did;
/* Allocate the dev and zero it out. */
dev = kzalloc(sizeof(struct xiic_data), SLAB_KERNEL);
if (!dev) {
dev_err(&of_dev->dev, "Cannot allocate struct xiic_data\n");
error = -ENOMEM;
goto out2;
}
dev_set_drvdata(&of_dev->dev, dev);
/* get resources from device tree */
dev->irq = irq_of_parse_and_map(dev_node, 0);
if (dev->irq == 0 /* NOIRQ */ ) {
error = -ENODEV;
goto out;
}
if (of_address_to_resource(dev_node, 0, &mem)) {
error = -ENODEV;
goto out;
}
/* initialize fields to satisfy i2c */
strcpy(dev->adap.name, of_dev->dev.bus_id);
did = of_get_property(dev_node, "index", NULL);
if (did == NULL) {
printk
("%s: Can not get device index from device tree, assume 0\n",
__FUNCTION__);
dev->index = 0;
} else
dev->index = *did;
init_completion(&dev->complete);
memset(&xiic_cfg, 0, sizeof(XIic_Config));
xiic_cfg.DeviceId = dev->index;
/* Change the addresses to be virtual; save the old ones to restore. */
dev->base = mem.start;
xiic_cfg.BaseAddress =
(u32) ioremap(mem.start, mem.end - mem.start + 1);
dev->remapped = 1;
down(&cfg_sem);
/* Tell the Xilinx code to bring this IIC interface up. */
if (XIic_CfgInitialize(&dev->Iic, &xiic_cfg, xiic_cfg.BaseAddress) !=
XST_SUCCESS) {
up(&cfg_sem);
dev_err(&of_dev->dev, "could not initialize device.\n");
error = -ENODEV;
goto out;
}
up(&cfg_sem);
XIic_SetRecvHandler(&dev->Iic, (void *)dev, RecvHandler);
XIic_SetSendHandler(&dev->Iic, (void *)dev, SendHandler);
XIic_SetStatusHandler(&dev->Iic, (void *)dev, StatusHandler);
/* Grab the IRQ */
error = request_irq(dev->irq, xiic_interrupt, 0, dev->adap.name, dev);
if (error) {
dev_err(&of_dev->dev, "could not allocate interrupt %d.\n",
dev->irq);
goto out;
}
dev->reqirq = 1;
if (XIic_Start(&dev->Iic) != XST_SUCCESS) {
dev_err(&of_dev->dev, "could not start device\n");
error = -ENODEV;
goto out;
}
dev->started = 1;
/* Now tell the core I2C code about our new device. */
/*
* SAATODO: Get a real ID (perhaps I2C_HW_XILINX) after
* initial release. Will need to email [email protected]
* per http://www2.lm-sensors.nu/~lm78/support.html
*/
dev->adap.id = I2C_DRIVERID_I2CDEV;
dev->adap.algo = &xiic_algo;
dev->adap.algo_data = NULL;
dev->adap.timeout = XIIC_TIMEOUT;
dev->adap.retries = XIIC_RETRY;
error = i2c_add_adapter(&dev->adap);
if (error) {
dev_err(&of_dev->dev, "could not add i2c adapter\n");
goto out;
}
dev->added = 1;
printk("%s #%d at 0x%08X mapped to 0x%08X, irq=%d\n",
dev->adap.name, dev->index,
dev->base, dev->Iic.BaseAddress, dev->irq);
if (scan) {
scan_results = xilinx_iic_do_scan(dev);
if (scan_results) {
printk(scan_results);
kfree(scan_results);
}
}
device_create_file(&of_dev->dev, &dev_attr_scan);
out:
if (error)
xilinx_iic_remove(of_dev);
out2:
return error;
}
static int __init xilinx_iic_probe(struct device *device)
{
XIic_Config xiic_cfg;
struct platform_device *pdev = to_platform_device(device);
struct xiic_data *dev;
char *scan_results;
struct resource *mem;
int error;
/* Allocate the dev and zero it out. */
dev = kzalloc(sizeof(struct xiic_data), SLAB_KERNEL);
if (!dev) {
dev_err(device, "Cannot allocate struct xiic_data\n");
error = -ENOMEM;
goto out2;
}
dev_set_drvdata(device, dev);
/* get resources from resource list of passed platform_device */
dev->irq = platform_get_irq(pdev, 0);
if (dev->irq == 0 /* NOIRQ */ ) {
error = -ENODEV;
goto out;
}
mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!mem) {
error = -ENODEV;
goto out;
}
/* initialize fields to satisfy i2c */
strcpy(dev->adap.name, device->bus_id);
dev->index = pdev->id;
init_completion(&dev->complete);
memset(&xiic_cfg, 0, sizeof(XIic_Config));
xiic_cfg.DeviceId = pdev->id;
/* Change the addresses to be virtual; save the old ones to restore. */
dev->base = mem->start;
xiic_cfg.BaseAddress =
(u32) ioremap(mem->start, mem->end - mem->start + 1);
dev->remapped = 1;
down(&cfg_sem);
/* Tell the Xilinx code to bring this IIC interface up. */
if (XIic_CfgInitialize(&dev->Iic, &xiic_cfg, xiic_cfg.BaseAddress) !=
XST_SUCCESS) {
up(&cfg_sem);
dev_err(device, "could not initialize device.\n");
error = -ENODEV;
goto out;
}
up(&cfg_sem);
XIic_SetRecvHandler(&dev->Iic, (void *)dev, RecvHandler);
XIic_SetSendHandler(&dev->Iic, (void *)dev, SendHandler);
XIic_SetStatusHandler(&dev->Iic, (void *)dev, StatusHandler);
/* Grab the IRQ */
error = request_irq(dev->irq, xiic_interrupt, 0, dev->adap.name, dev);
if (error) {
dev_err(device, "could not allocate interrupt %d.\n", dev->irq);
goto out;
}
dev->reqirq = 1;
if (XIic_Start(&dev->Iic) != XST_SUCCESS) {
dev_err(device, "could not start device\n");
error = -ENODEV;
goto out;
}
dev->started = 1;
/* Now tell the core I2C code about our new device. */
/*
* SAATODO: Get a real ID (perhaps I2C_HW_XILINX) after
* initial release. Will need to email [email protected]
* per http://www2.lm-sensors.nu/~lm78/support.html
*/
dev->adap.id = xiic_algo.id | I2C_DRIVERID_EXP0;
dev->adap.algo = &xiic_algo;
dev->adap.algo_data = NULL;
dev->adap.timeout = XIIC_TIMEOUT;
dev->adap.retries = XIIC_RETRY;
error = i2c_add_adapter(&dev->adap);
if (error) {
dev_err(device, "could not add i2c adapter\n");
goto out;
}
dev->added = 1;
printk("%s #%d at 0x%08X mapped to 0x%08X, irq=%d\n",
dev->adap.name, dev->index,
dev->base, dev->Iic.BaseAddress, dev->irq);
if (scan) {
scan_results = xilinx_iic_do_scan(dev);
if (scan_results) {
printk(scan_results);
kfree(scan_results);
}
}
device_create_file(device, &dev_attr_scan);
out:
if (error)
xilinx_iic_remove(device);
out2:
return error;
}
/**
* 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;
}
