Merge branch 'upstream-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/ieee13...

[pandora-kernel.git] / drivers / i2c / busses / i2c-mv64xxx.c

diff --git a/drivers/i2c/busses/i2c-mv64xxx.c b/drivers/i2c/busses/i2c-mv64xxx.c
index afd7634..eacbaf7 100644 (file)
--- a/drivers/i2c/busses/i2c-mv64xxx.c
+++ b/drivers/i2c/busses/i2c-mv64xxx.c
@@ -1,6 +1,4 @@
 /*
- * drivers/i2c/busses/i2c-mv64xxx.c
- * 
  * Driver for the i2c controller on the Marvell line of host bridges for MIPS
  * and PPC (e.g, gt642[46]0, mv643[46]0, mv644[46]0).
  *
@@ -65,7 +63,6 @@ enum {
        MV64XXX_I2C_STATE_WAITING_FOR_ADDR_2_ACK,
        MV64XXX_I2C_STATE_WAITING_FOR_SLAVE_ACK,
        MV64XXX_I2C_STATE_WAITING_FOR_SLAVE_DATA,
-       MV64XXX_I2C_STATE_ABORTING,
 };
 
 /* Driver actions */
@@ -85,6 +82,7 @@ struct mv64xxx_i2c_data {
        int                     irq;
        u32                     state;
        u32                     action;
+       u32                     aborting;
        u32                     cntl_bits;
        void __iomem            *reg_base;
        u32                     reg_base_p;
@@ -122,12 +120,6 @@ mv64xxx_i2c_fsm(struct mv64xxx_i2c_data *drv_data, u32 status)
                return;
        }
 
-       if (drv_data->state == MV64XXX_I2C_STATE_ABORTING) {
-               drv_data->action = MV64XXX_I2C_ACTION_SEND_STOP;
-               drv_data->state = MV64XXX_I2C_STATE_IDLE;
-               return;
-       }
-
        /* The status from the ctlr [mostly] tells us what to do next */
        switch (status) {
        /* Start condition interrupt */
@@ -148,14 +140,16 @@ mv64xxx_i2c_fsm(struct mv64xxx_i2c_data *drv_data, u32 status)
                /* FALLTHRU */
        case MV64XXX_I2C_STATUS_MAST_WR_ADDR_2_ACK: /* 0xd0 */
        case MV64XXX_I2C_STATUS_MAST_WR_ACK: /* 0x28 */
-               if (drv_data->bytes_left > 0) {
+               if ((drv_data->bytes_left == 0)
+                               || (drv_data->aborting
+                                       && (drv_data->byte_posn != 0))) {
+                       drv_data->action = MV64XXX_I2C_ACTION_SEND_STOP;
+                       drv_data->state = MV64XXX_I2C_STATE_IDLE;
+               } else {
                        drv_data->action = MV64XXX_I2C_ACTION_SEND_DATA;
                        drv_data->state =
                                MV64XXX_I2C_STATE_WAITING_FOR_SLAVE_ACK;
                        drv_data->bytes_left--;
-               } else {
-                       drv_data->action = MV64XXX_I2C_ACTION_SEND_STOP;
-                       drv_data->state = MV64XXX_I2C_STATE_IDLE;
                }
                break;
 
@@ -184,7 +178,7 @@ mv64xxx_i2c_fsm(struct mv64xxx_i2c_data *drv_data, u32 status)
                }
                drv_data->state = MV64XXX_I2C_STATE_WAITING_FOR_SLAVE_DATA;
 
-               if (drv_data->bytes_left == 1)
+               if ((drv_data->bytes_left == 1) || drv_data->aborting)
                        drv_data->cntl_bits &= ~MV64XXX_I2C_REG_CONTROL_ACK;
                break;
 
@@ -320,6 +314,7 @@ mv64xxx_i2c_prepare_for_io(struct mv64xxx_i2c_data *drv_data,
        drv_data->msg = msg;
        drv_data->byte_posn = 0;
        drv_data->bytes_left = msg->len;
+       drv_data->aborting = 0;
        drv_data->rc = 0;
        drv_data->cntl_bits = MV64XXX_I2C_REG_CONTROL_ACK |
                MV64XXX_I2C_REG_CONTROL_INTEN | MV64XXX_I2C_REG_CONTROL_TWSIEN;
@@ -359,17 +354,19 @@ mv64xxx_i2c_wait_for_completion(struct mv64xxx_i2c_data *drv_data)
        }
 
        if (abort && drv_data->block) {
-               drv_data->state = MV64XXX_I2C_STATE_ABORTING;
+               drv_data->aborting = 1;
                spin_unlock_irqrestore(&drv_data->lock, flags);
 
                time_left = wait_event_timeout(drv_data->waitq,
                        !drv_data->block,
                        msecs_to_jiffies(drv_data->adapter.timeout));
 
-               if (time_left <= 0) {
+               if ((time_left <= 0) && drv_data->block) {
                        drv_data->state = MV64XXX_I2C_STATE_IDLE;
                        dev_err(&drv_data->adapter.dev,
-                               "mv64xxx: I2C bus locked\n");
+                               "mv64xxx: I2C bus locked, block: %d, "
+                               "time_left: %d\n", drv_data->block,
+                               (int)time_left);
                }
        } else
                spin_unlock_irqrestore(&drv_data->lock, flags);
@@ -434,7 +431,7 @@ mv64xxx_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msgs[], int num)
        return num;
 }
 
-static struct i2c_algorithm mv64xxx_i2c_algo = {
+static const struct i2c_algorithm mv64xxx_i2c_algo = {
        .master_xfer = mv64xxx_i2c_xfer,
        .functionality = mv64xxx_i2c_functionality,
 };
@@ -510,7 +507,7 @@ mv64xxx_i2c_probe(struct platform_device *pd)
                goto exit_kfree;
        }
 
-       strncpy(drv_data->adapter.name, MV64XXX_I2C_CTLR_NAME " adapter",
+       strlcpy(drv_data->adapter.name, MV64XXX_I2C_CTLR_NAME " adapter",
                I2C_NAME_SIZE);
 
        init_waitqueue_head(&drv_data->waitq);
@@ -519,6 +516,10 @@ mv64xxx_i2c_probe(struct platform_device *pd)
        drv_data->freq_m = pdata->freq_m;
        drv_data->freq_n = pdata->freq_n;
        drv_data->irq = platform_get_irq(pd, 0);
+       if (drv_data->irq < 0) {
+               rc = -ENXIO;
+               goto exit_unmap_regs;
+       }
        drv_data->adapter.id = I2C_HW_MV64XXX;
        drv_data->adapter.algo = &mv64xxx_i2c_algo;
        drv_data->adapter.owner = THIS_MODULE;
@@ -529,14 +530,15 @@ mv64xxx_i2c_probe(struct platform_device *pd)
        i2c_set_adapdata(&drv_data->adapter, drv_data);
 
        if (request_irq(drv_data->irq, mv64xxx_i2c_intr, 0,
-               MV64XXX_I2C_CTLR_NAME, drv_data)) {
-
-               dev_err(dev, "mv64xxx: Can't register intr handler "
-                       "irq: %d\n", drv_data->irq);
+                       MV64XXX_I2C_CTLR_NAME, drv_data)) {
+               dev_err(&drv_data->adapter.dev,
+                       "mv64xxx: Can't register intr handler irq: %d\n",
+                       drv_data->irq);
                rc = -EINVAL;
                goto exit_unmap_regs;
        } else if ((rc = i2c_add_adapter(&drv_data->adapter)) != 0) {
-               dev_err(dev, "mv64xxx: Can't add i2c adapter, rc: %d\n", -rc);
+               dev_err(&drv_data->adapter.dev,
+                       "mv64xxx: Can't add i2c adapter, rc: %d\n", -rc);
                goto exit_free_irq;
        }