Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-11-13 23:51:39 +00:00
Code Issues Packages Projects Releases Wiki Activity

i2c-designware: Process i2c_msg messages in the interrupt handler

Browse Source 
Symptom:
--------
When we're going to send/receive the longer size of data than the Tx
FIFO length, the I2C transaction will be divided into several separated
transactions, limited by the Tx FIFO length.

Details:
--------
As a hardware feature, DW I2C core generates a STOP condition whenever
the Tx FIFO becomes empty (strictly speaking, whenever the last byte in
the Tx FIFO is sent out), even if we have more bytes to be written.
Then, once a new transmit data is written to the Tx FIFO, DW I2C core
will initiate a new transaction, which leads to another START condition.

This explains how the transaction in question goes, and implies that
current tasklet-based dw_i2c_pump_msg() strategy couldn't meet the
timing constraint required for avoiding Tx FIFO underrun.

To avoid this scenario, we must keep providing new transmit data within
a given time period.  In case of Fast-mode + 32-byte Tx FIFO, for
instance, it takes about 22.5[us] to process single byte, and 720[us] in
total.

This patch removes the existing tasklet-based "pump" system, and move
its jobs into the interrupt handler.

Signed-off-by: Shinya Kuribayashi <shinya.kuribayashi@necel.com>
Acked-by: Baruch Siach <baruch@tkos.co.il>
Signed-off-by: Ben Dooks <ben-linux@fluff.org>
This commit is contained in:
Shinya Kuribayashi 2009-11-06 21:47:51 +09:00 committed by Ben Dooks
parent c70c5cd374
commit 0774539948
1 changed files with 14 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
drivers/i2c/busses/i2c-designware.c
View File

@ -149,7 +149,6 @@ static char *abort_sources[] = {
* @dev: driver model device node * @dev: driver model device node
* @base: IO registers pointer * @base: IO registers pointer
* @cmd_complete: tx completion indicator * @cmd_complete: tx completion indicator
* @pump_msg: continue in progress transfers
* @lock: protect this struct and IO registers * @lock: protect this struct and IO registers
* @clk: input reference clock * @clk: input reference clock
* @cmd_err: run time hadware error code * @cmd_err: run time hadware error code
@ -175,7 +174,6 @@ struct dw_i2c_dev {
struct device *dev; struct device *dev;
void __iomem *base; void __iomem *base;
struct completion cmd_complete; struct completion cmd_complete;
struct tasklet_struct pump_msg;
struct mutex lock; struct mutex lock;
struct clk *clk; struct clk *clk;
int cmd_err; int cmd_err;
@ -325,7 +323,7 @@ static int i2c_dw_wait_bus_not_busy(struct dw_i2c_dev *dev)
/* /*
* Initiate low level master read/write transaction. * Initiate low level master read/write transaction.
* This function is called from i2c_dw_xfer when starting a transfer. * This function is called from i2c_dw_xfer when starting a transfer.
* This function is also called from dw_i2c_pump_msg to continue a transfer * This function is also called from i2c_dw_isr to continue a transfer
* that is longer than the size of the TX FIFO. * that is longer than the size of the TX FIFO.
*/ */
static void static void
@ -489,10 +487,7 @@ i2c_dw_xfer(struct i2c_adapter *adap, struct i2c_msg msgs[], int num)
/* no error */ /* no error */
if (likely(!dev->cmd_err)) { if (likely(!dev->cmd_err)) {
/* read rx fifo, and disable the adapter */ /* Disable the adapter */
do {
i2c_dw_read(dev);
} while (dev->status & STATUS_READ_IN_PROGRESS);
writel(0, dev->base + DW_IC_ENABLE); writel(0, dev->base + DW_IC_ENABLE);
ret = num; ret = num;
goto done; goto done;
@ -520,20 +515,6 @@ static u32 i2c_dw_func(struct i2c_adapter *adap)
return I2C_FUNC_I2C | I2C_FUNC_10BIT_ADDR; return I2C_FUNC_I2C | I2C_FUNC_10BIT_ADDR;
} }
static void dw_i2c_pump_msg(unsigned long data)
{
struct dw_i2c_dev *dev = (struct dw_i2c_dev *) data;
u32 intr_mask;
i2c_dw_read(dev);
i2c_dw_xfer_msg(dev);
intr_mask = DW_IC_INTR_STOP_DET | DW_IC_INTR_TX_ABRT;
if (dev->status & STATUS_WRITE_IN_PROGRESS)
intr_mask |= DW_IC_INTR_TX_EMPTY;
writel(intr_mask, dev->base + DW_IC_INTR_MASK);
}
static u32 i2c_dw_read_clear_intrbits(struct dw_i2c_dev *dev) static u32 i2c_dw_read_clear_intrbits(struct dw_i2c_dev *dev)
{ {
u32 stat; u32 stat;
@ -604,10 +585,19 @@ static irqreturn_t i2c_dw_isr(int this_irq, void *dev_id)
if (stat & DW_IC_INTR_TX_ABRT) { if (stat & DW_IC_INTR_TX_ABRT) {
dev->cmd_err |= DW_IC_ERR_TX_ABRT; dev->cmd_err |= DW_IC_ERR_TX_ABRT;
dev->status = STATUS_IDLE; dev->status = STATUS_IDLE;
} else if (stat & DW_IC_INTR_TX_EMPTY) }
tasklet_schedule(&dev->pump_msg);
if (stat & DW_IC_INTR_TX_EMPTY) {
i2c_dw_read(dev);
i2c_dw_xfer_msg(dev);
}
/*
* No need to modify or disable the interrupt mask here.
* i2c_dw_xfer_msg() will take care of it according to
* the current transmit status.
*/
writel(0, dev->base + DW_IC_INTR_MASK); /* disable interrupts */
if (stat & (DW_IC_INTR_TX_ABRT | DW_IC_INTR_STOP_DET)) if (stat & (DW_IC_INTR_TX_ABRT | DW_IC_INTR_STOP_DET))
complete(&dev->cmd_complete); complete(&dev->cmd_complete);
@ -653,7 +643,6 @@ static int __devinit dw_i2c_probe(struct platform_device *pdev)
} }
init_completion(&dev->cmd_complete); init_completion(&dev->cmd_complete);
tasklet_init(&dev->pump_msg, dw_i2c_pump_msg, (unsigned long) dev);
mutex_init(&dev->lock); mutex_init(&dev->lock);
dev->dev = get_device(&pdev->dev); dev->dev = get_device(&pdev->dev);
dev->irq = irq; dev->irq = irq;