/*** TMP3_WriteIIC
**
** Parameters:
** InstancePtr - PmodTMP3 object to initialize
** reg - Register to send to
** Data - Pointer to data buffer to send
** nData - Number of data values to send
**
** Return Value:
** none
**
** Errors:
** none
**
** Description:
** Writes nData data bytes to register reg
**
*/
void TMP3_WriteIIC(PmodTMP3* InstancePtr, u8 reg, u8 *Data, int nData)
{
u8 out[10];
out[0]=reg;
out[1]=*Data;
int Status;
if (InstancePtr->currentRegister!=reg){
InstancePtr->currentRegister=reg;
}
Status = XIic_Start(&InstancePtr->TMP3Iic);
if (Status != XST_SUCCESS) {
return;
}
XIic_Send(InstancePtr->TMP3Iic.BaseAddress, InstancePtr->chipAddr, out, nData+1, XIIC_STOP);
//XIic_MasterSend(&InstancePtr->TMP3Iic, out, nData+1);
//XIic_DynMasterSend(&InstancePtr->TMP3Iic, out, nData+1);
//while(XIic_IsIicBusy(&InstancePtr->TMP3Iic));
Status = XIic_Stop(&InstancePtr->TMP3Iic);
if (Status != XST_SUCCESS) {
return;
}
}
/*** TMP3_ReadIIC
**
** Parameters:
** InstancePtr - PmodTMP3 object to initialize
** reg - Register to read from
** Data - Pointer to recieve buffer
** nData - Number of data values to read
**
** Return Value:
** none
**
** Errors:
** none
**
** Description:
** Reads nData data bytes from register reg
**
*/
void TMP3_ReadIIC(PmodTMP3* InstancePtr, u8 reg, u8 *Data, int nData)
{
int Status;
Status = XIic_Start(&InstancePtr->TMP3Iic);
if (Status != XST_SUCCESS) {
return;
}
if (InstancePtr->currentRegister!=reg){
//XIic_MasterSend(&InstancePtr->TMP3Iic, ®, 1);
XIic_Send(InstancePtr->TMP3Iic.BaseAddress, InstancePtr->chipAddr, ®, 1, XII_REPEATED_START_OPTION);
InstancePtr->currentRegister=reg;
}//else{
//XIic_MasterRecv(&InstancePtr->TMP3Iic, Data, nData);
//}
XIic_Recv(InstancePtr->TMP3Iic.BaseAddress, InstancePtr->chipAddr, Data, nData, XIIC_STOP);
//XIic_MasterSend(&InstancePtr->TMP3Iic, ®, 2);
//InstancePtr->recvbytes=nData+1;
//InstancePtr->recv=Data;
//XIic_MasterRecv(&InstancePtr->TMP3Iic, Data, nData);
Status = XIic_Stop(&InstancePtr->TMP3Iic);
if (Status != XST_SUCCESS) {
return;
}
}
static int __devexit xilinx_iic_remove(struct device *device)
{
struct xiic_data *dev;
dev = dev_get_drvdata(device);
/*
* If we've told the core I2C code about this dev, tell
* the core I2C code to forget the dev.
*/
if (dev->added) {
/*
* If an error is returned, there's not a whole lot we can
* do. An error has already been printed out so we'll
* just keep trundling along.
*/
(void)i2c_del_adapter(&dev->adap);
}
/* Tell the Xilinx code to take this IIC interface down. */
if (dev->started) {
while (XIic_Stop(&dev->Iic) != XST_SUCCESS) {
/* The bus was busy. Retry. */
printk(KERN_WARNING
"%s #%d: Could not stop device. Will retry.\n",
dev->adap.name, dev->index);
set_current_state(TASK_INTERRUPTIBLE);
schedule_timeout(HZ / 2);
}
}
/*
* Now that the Xilinx code isn't using the IRQ or registers,
* unmap the registers and free the IRQ.
*/
if (dev->remapped) {
iounmap((void *)dev->Iic.BaseAddress);
}
if (dev->reqirq) {
disable_irq(dev->irq);
free_irq(dev->irq, dev);
}
device_remove_file(device, &dev_attr_scan);
kfree(dev);
return 0;
}
static int
xiic_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg msgs[], int num)
{
struct xiic_data *dev = (struct xiic_data *) i2c_adap;
struct i2c_msg *pmsg;
u32 options;
int i, retries;
u32 Status;
u32 writeop;
for (i = 0; i < num; i++)
{
pmsg = &msgs[i];
if (!pmsg->len) /* If length is zero */
continue; /* on to the next request. */
/*
* This code checks up to 16 times for the
* bus busy condition.
*/
retries = 4;
while((XIic_IsIicBusy(&dev->Iic) == TRUE) &&
(retries-- != 0))
{
set_current_state(TASK_INTERRUPTIBLE);
schedule_timeout(HZ/250);
}
/* If bus is still busy, bail */
if (XIic_IsIicBusy(&dev->Iic) == TRUE)
{
printk(KERN_WARNING
"%s #%d: Could not talk to device 0x%2x (%d), bus always busy, trying to reset\n",
dev->adap.name, dev->index, pmsg->addr,
dev->status_intr_flag);
/* Try stopping, reseting and starting device to clear condition
*/
if (XIic_Stop(&dev->Iic) != XST_SUCCESS)
{
/* The bus was in use.. */
printk(KERN_WARNING
"%s #%d: Could not stop device. Restart from higher layer.\n",
dev->adap.name, dev->index);
return -ENXIO;
}
else
{
XIic_Reset(&dev->Iic);
if (XIic_Start(&dev->Iic) != XST_SUCCESS)
{
printk(KERN_ERR "%s #%d: Could not start device.\n",
dev->adap.name, dev->index);
return -ENODEV;
}
return -ENXIO;
}
}
options = 0;
if (pmsg->flags & I2C_M_TEN)
options |= XII_SEND_10_BIT_OPTION;
XIic_SetOptions(&dev->Iic, options);
if (XIic_SetAddress(&dev->Iic, XII_ADDR_TO_SEND_TYPE,
pmsg->addr) != XST_SUCCESS)
{
printk(KERN_WARNING
"%s #%d: Could not set address to 0x%2x.\n",
dev->adap.name, dev->index, pmsg->addr);
return -EIO;
}
dev->transmit_intr_flag = 0xFFFFFFFF;
dev->receive_intr_flag = 0xFFFFFFFF;
dev->status_intr_flag = 0xFFFFFFFF;
/* set the writeop flag to 0 so the adapter does not wait
* at bottom of loop
*/
writeop = 0;
dev->Iic.Stats.TxErrors = 0;
if (pmsg->flags & I2C_M_RD)
{
Status = XIic_MasterRecv(&dev->Iic, pmsg->buf, pmsg->len);
}
else
{
Status = XIic_MasterSend(&dev->Iic, pmsg->buf, pmsg->len);
}
if (Status != XST_SUCCESS)
{
printk(KERN_WARNING
"%s #%d: Unexpected error %d.\n",
dev->adap.name, dev->index, (int)Status);
return -EIO;
}
/*
* Wait till the data is transmitted or received. If there is an error
* retry for 10 times.
*/
retries = 10;
if(pmsg->flags & I2C_M_RD)
{
while((((volatile int)(dev->receive_intr_flag)) != 0) && (retries != 0))
{
if ( dev->Iic.Stats.TxErrors != 0)
{
udelay(25);
Status = XIic_MasterRecv(&dev->Iic, pmsg->buf, pmsg->len);
dev->Iic.Stats.TxErrors = 0;
retries--;
}
/* the udelay was not working for Microblaze and this seems
like a better solution */
schedule_timeout_interruptible(1);
}
}
else
{
while((((volatile int)(dev->transmit_intr_flag)) != 0) && (retries != 0))
{
if ( dev->Iic.Stats.TxErrors != 0)
{
udelay(25);
Status = XIic_MasterSend(&dev->Iic, pmsg->buf, pmsg->len);
dev->Iic.Stats.TxErrors = 0;
retries--;
}
/* the udelay was not working for Microblaze and this seems
like a better solution */
schedule_timeout_interruptible(1);
}
}
if(retries == 0)
{
printk("Unable to talk to Device\n");
printk("Wrong Slave address or Slave device Busy\n");
}
}
return num;
}
/*
* *********************************************************
* IicWriteData with address added as an input parameter
* *********************************************************
*/
int IicWriteData(u8 IicAddr, u8 *BufferPtr, u16 ByteCount)
{
int Status;
u32 IicTimeoutCounter = 0;
// Mark the Transmit Flag
TransmitComplete = 1;
IicInstance.Stats.TxErrors = 0;
/*
* Start Iic Device
*/
Status = XIic_Start(&IicInstance);
if (Status != XST_SUCCESS) {
#ifdef IIC_DEBUG
xil_printf("IicWriteData: IIC Start Device Failed with status %x\r\n", Status);
#endif
return XST_FAILURE;
}
/*
* Set Iic Address
*/
Status = XIic_SetAddress(&IicInstance, XII_ADDR_TO_SEND_TYPE, IicAddr);
if (Status != XST_SUCCESS) {
#ifdef IIC_DEBUG
xil_printf("IicWriteData: IIC Set Address Failed with status %x\r\n", Status);
#endif
return XST_FAILURE;
}
/*
* Send the Data
*/
Status = XIic_MasterSend(&IicInstance, BufferPtr, ByteCount);
if (Status != XST_SUCCESS) {
#ifdef IIC_DEBUG
xil_printf("IicWriteData: IIC Master Send failed with status %x\r\n", Status);
#endif
return XST_FAILURE;
}
/*
* Wait till the transmission is completed
*/
while(((TransmitComplete) || (XIic_IsIicBusy(&IicInstance)==TRUE)) && IicTimeoutCounter <= IIC_TIMEOUT) {
IicTimeoutCounter++;
}
if (IicTimeoutCounter > IIC_TIMEOUT) {
TransmitComplete = 0;
XIic_Reset(&IicInstance);
Status = XIic_Stop(&IicInstance);
#ifdef IIC_DEBUG
xil_printf("IicWriteData: IIC Write Timeout!\r\n");
if (Status != XST_SUCCESS) {
xil_printf("IicWriteData: IIC stop failed with status %x\r\n", Status);
}
#endif
return XST_FAILURE;
}
/*
* Stop Iic Device
*/
Status = XIic_Stop(&IicInstance);
if (Status != XST_SUCCESS) {
#ifdef IIC_DEBUG
xil_printf("IicWriteData: IIC Stop failed with status %x\r\n", Status);
#endif
return XST_FAILURE;
}
return XST_SUCCESS;
}
/*
* *********************************************************
* IicReadData3 with address added as an input parameter - two bytes address
* *********************************************************
*/
int IicReadData3(u8 IicAddr, u16 addr, u8 *BufferPtr, u16 ByteCount)
{
int Status;
u8 IicOptions;
u32 IicTimeoutCounter = 0;
/*
* Set Receive Flag
*/
ReceiveComplete = 1;
/*
* Start Iic Device
*/
Status = XIic_Start(&IicInstance);
if (Status != XST_SUCCESS) {
#ifdef IIC_DEBUG
xil_printf("IicReadData3: IIC Start failed with status %x\r\n", Status);
#endif
return XST_FAILURE;
}
/*
* Set Iic Address
*/
Status = XIic_SetAddress(&IicInstance, XII_ADDR_TO_SEND_TYPE, IicAddr);
if (Status != XST_SUCCESS) {
#ifdef IIC_DEBUG
xil_printf("IicReadData3: IIC Set Address failed with status %x\r\n", Status);
#endif
return XST_FAILURE;
}
/*
* Write addr to the device
*/
// Mark the Transmit Flag
TransmitComplete = 1;
IicInstance.Stats.TxErrors = 0;
/*
* Send the Data
*/
u8 addrReorder[2];
u8 *addrPtr;
addrPtr = &addr;
addrReorder[0] = addrPtr[1];
addrReorder[1] = addrPtr[0];
Status = XIic_MasterSend(&IicInstance, addrReorder, 2);
if (Status != XST_SUCCESS) {
#ifdef IIC_DEBUG
xil_printf("IicReadData3: IIC Master Send failed with status %x\r\n", Status);
#endif
return XST_FAILURE;
}
/*
* Wait till the transmission is completed
*/
while(((TransmitComplete) || (XIic_IsIicBusy(&IicInstance)==TRUE)) && IicTimeoutCounter <= IIC_TIMEOUT) {
IicTimeoutCounter ++;
}
/*
* Handle Tx Timeout
*/
if (IicTimeoutCounter > IIC_TIMEOUT) {
XIic_Reset(&IicInstance);
Status = XIic_Stop(&IicInstance);
#ifdef IIC_DEBUG
xil_printf("IicReadData3: IIC Write Timeout!\r\n");
if (Status != XST_SUCCESS) {
xil_printf("IicReadData3: IIC Stop Failed with status %x\r\n", Status);
}
#endif
return XST_FAILURE;
}
/*
* Receive Data
*/
Status = XIic_MasterRecv(&IicInstance, BufferPtr, ByteCount);
if(Status != XST_SUCCESS) {
if (Status != XST_SUCCESS) {
#ifdef IIC_DEBUG
xil_printf("IicReadData3: IIC Master Recv Failed with status %x\r\n", Status);
#endif
return XST_FAILURE;
}
}
/*
* Wait until all the data is received
*/
IicTimeoutCounter = 0;
while(((ReceiveComplete) || (XIic_IsIicBusy(&IicInstance)==TRUE)) && IicTimeoutCounter <= IIC_TIMEOUT) {
IicTimeoutCounter ++;
}
/*
* Handle Rx Timeout
*/
if (IicTimeoutCounter > IIC_TIMEOUT) {
XIic_Reset(&IicInstance);
Status = XIic_Stop(&IicInstance);
#ifdef IIC_DEBUG
xil_printf("IicReadData3: IIC Recv Timeout!\r\n");
if (Status != XST_SUCCESS) {
xil_printf("IicReadData3: IIC Stop Failed with status %x\r\n", Status);
}
#endif
return XST_FAILURE;
}
/*
* Stop Iic
*/
Status = XIic_Stop(&IicInstance);
if (Status != XST_SUCCESS) {
#ifdef IIC_DEBUG
xil_printf("IicReadData3: IIC Stop Failed with status %x\r\n", Status);
#endif
return XST_FAILURE;
}
return XST_SUCCESS;
}