include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit...

[safe/jmp/linux-2.6] / drivers / i2c / busses / i2c-pca-platform.c

diff --git a/drivers/i2c/busses/i2c-pca-platform.c b/drivers/i2c/busses/i2c-pca-platform.c
index 6bb15ad..5b2213d 100644 (file)
--- a/drivers/i2c/busses/i2c-pca-platform.c
+++ b/drivers/i2c/busses/i2c-pca-platform.c
@@ -15,6 +15,7 @@
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/delay.h>
+#include <linux/jiffies.h>
 #include <linux/errno.h>
 #include <linux/i2c.h>
 #include <linux/interrupt.h>
@@ -26,8 +27,6 @@
 #include <asm/irq.h>
 #include <asm/io.h>
 
-#define res_len(r)             ((r)->end - (r)->start + 1)
-
 struct i2c_pca_pf_data {
        void __iomem                    *reg_base;
        int                             irq;    /* if 0, use polling */
@@ -81,24 +80,23 @@ static void i2c_pca_pf_writebyte32(void *pd, int reg, int val)
 static int i2c_pca_pf_waitforcompletion(void *pd)
 {
        struct i2c_pca_pf_data *i2c = pd;
-       int ret = 0;
+       long ret = ~0;
+       unsigned long timeout;
 
        if (i2c->irq) {
-               ret = wait_event_interruptible(i2c->wait,
+               ret = wait_event_timeout(i2c->wait,
                        i2c->algo_data.read_byte(i2c, I2C_PCA_CON)
-                       & I2C_PCA_CON_SI);
+                       & I2C_PCA_CON_SI, i2c->adap.timeout);
        } else {
-               /*
-                * Do polling...
-                * XXX: Could get stuck in extreme cases!
-                *      Maybe add timeout, but using irqs is preferred anyhow.
-                */
-               while ((i2c->algo_data.read_byte(i2c, I2C_PCA_CON)
+               /* Do polling */
+               timeout = jiffies + i2c->adap.timeout;
+               while (((i2c->algo_data.read_byte(i2c, I2C_PCA_CON)
                                & I2C_PCA_CON_SI) == 0)
+                               && (ret = time_before(jiffies, timeout)))
                        udelay(100);
        }
 
-       return ret;
+       return ret > 0;
 }
 
 static void i2c_pca_pf_dummyreset(void *pd)
@@ -124,7 +122,7 @@ static irqreturn_t i2c_pca_pf_handler(int this_irq, void *dev_id)
        if ((i2c->algo_data.read_byte(i2c, I2C_PCA_CON) & I2C_PCA_CON_SI) == 0)
                return IRQ_NONE;
 
-       wake_up_interruptible(&i2c->wait);
+       wake_up(&i2c->wait);
 
        return IRQ_HANDLED;
 }
@@ -148,7 +146,7 @@ static int __devinit i2c_pca_pf_probe(struct platform_device *pdev)
                goto e_print;
        }
 
-       if (!request_mem_region(res->start, res_len(res), res->name)) {
+       if (!request_mem_region(res->start, resource_size(res), res->name)) {
                ret = -ENOMEM;
                goto e_print;
        }
@@ -161,25 +159,36 @@ static int __devinit i2c_pca_pf_probe(struct platform_device *pdev)
 
        init_waitqueue_head(&i2c->wait);
 
-       i2c->reg_base = ioremap(res->start, res_len(res));
+       i2c->reg_base = ioremap(res->start, resource_size(res));
        if (!i2c->reg_base) {
                ret = -ENOMEM;
                goto e_remap;
        }
        i2c->io_base = res->start;
-       i2c->io_size = res_len(res);
+       i2c->io_size = resource_size(res);
        i2c->irq = irq;
 
        i2c->adap.nr = pdev->id >= 0 ? pdev->id : 0;
        i2c->adap.owner = THIS_MODULE;
-       snprintf(i2c->adap.name, sizeof(i2c->adap.name), "PCA9564 at 0x%08lx",
-               (unsigned long) res->start);
+       snprintf(i2c->adap.name, sizeof(i2c->adap.name),
+                "PCA9564/PCA9665 at 0x%08lx",
+                (unsigned long) res->start);
        i2c->adap.algo_data = &i2c->algo_data;
        i2c->adap.dev.parent = &pdev->dev;
-       i2c->adap.timeout = platform_data->timeout;
 
-       i2c->algo_data.i2c_clock = platform_data->i2c_clock_speed;
+       if (platform_data) {
+               i2c->adap.timeout = platform_data->timeout;
+               i2c->algo_data.i2c_clock = platform_data->i2c_clock_speed;
+               i2c->gpio = platform_data->gpio;
+       } else {
+               i2c->adap.timeout = HZ;
+               i2c->algo_data.i2c_clock = 59000;
+               i2c->gpio = -1;
+       }
+
        i2c->algo_data.data = i2c;
+       i2c->algo_data.wait_for_completion = i2c_pca_pf_waitforcompletion;
+       i2c->algo_data.reset_chip = i2c_pca_pf_dummyreset;
 
        switch (res->flags & IORESOURCE_MEM_TYPE_MASK) {
        case IORESOURCE_MEM_32BIT:
@@ -197,11 +206,6 @@ static int __devinit i2c_pca_pf_probe(struct platform_device *pdev)
                break;
        }
 
-       i2c->algo_data.wait_for_completion = i2c_pca_pf_waitforcompletion;
-
-       i2c->gpio = platform_data->gpio;
-       i2c->algo_data.reset_chip = i2c_pca_pf_dummyreset;
-
        /* Use gpio_is_valid() when in mainline */
        if (i2c->gpio > -1) {
                ret = gpio_request(i2c->gpio, i2c->adap.name);
@@ -244,9 +248,9 @@ e_reqirq:
 e_remap:
        kfree(i2c);
 e_alloc:
-       release_mem_region(res->start, res_len(res));
+       release_mem_region(res->start, resource_size(res));
 e_print:
-       printk(KERN_ERR "Registering PCA9564 FAILED! (%d)\n", ret);
+       printk(KERN_ERR "Registering PCA9564/PCA9665 FAILED! (%d)\n", ret);
        return ret;
 }
 
@@ -290,7 +294,7 @@ static void __exit i2c_pca_pf_exit(void)
 }
 
 MODULE_AUTHOR("Wolfram Sang <w.sang@pengutronix.de>");
-MODULE_DESCRIPTION("I2C-PCA9564 platform driver");
+MODULE_DESCRIPTION("I2C-PCA9564/PCA9665 platform driver");
 MODULE_LICENSE("GPL");
 
 module_init(i2c_pca_pf_init);