9 files changed, 53 insertions, 45 deletions

diff --git a/drivers/w1/masters/ds1wm.c b/drivers/w1/masters/ds1wm.c
index 29e144f81cbe..37f08c850608 100644
--- a/drivers/w1/masters/ds1wm.c
+++ b/drivers/w1/masters/ds1wm.c
@@ -16,10 +16,10 @@
 #include <linux/irq.h>
 #include <linux/pm.h>
 #include <linux/platform_device.h>
-#include <linux/clk.h>
 #include <linux/err.h>
 #include <linux/delay.h>
-#include <linux/ds1wm.h>
+#include <linux/mfd/core.h>
+#include <linux/mfd/ds1wm.h>
 
 #include <asm/io.h>
 
@@ -89,10 +89,9 @@ struct ds1wm_data {
         void            __iomem *map;
         int             bus_shift; /* # of shifts to calc register offsets */
         struct platform_device *pdev;
-        struct ds1wm_platform_data *pdata;
+        struct mfd_cell *cell;
         int             irq;
         int             active_high;
-        struct clk      *clk;
         int             slave_present;
         void            *reset_complete;
         void            *read_complete;
@@ -215,17 +214,17 @@ static int ds1wm_find_divisor(int gclk)
 
 static void ds1wm_up(struct ds1wm_data *ds1wm_data)
 {
-        int gclk, divisor;
+        int divisor;
+        struct ds1wm_driver_data *plat = ds1wm_data->cell->driver_data;
 
-        if (ds1wm_data->pdata->enable)
-                ds1wm_data->pdata->enable(ds1wm_data->pdev);
+        if (ds1wm_data->cell->enable)
+                ds1wm_data->cell->enable(ds1wm_data->pdev);
 
-        gclk = clk_get_rate(ds1wm_data->clk);
-        clk_enable(ds1wm_data->clk);
-        divisor = ds1wm_find_divisor(gclk);
+        divisor = ds1wm_find_divisor(plat->clock_rate);
         if (divisor == 0) {
                 dev_err(&ds1wm_data->pdev->dev,
-                        "no suitable divisor for %dHz clock\n", gclk);
+                        "no suitable divisor for %dHz clock\n",
+                        plat->clock_rate);
                 return;
         }
         ds1wm_write_register(ds1wm_data, DS1WM_CLKDIV, divisor);
@@ -244,10 +243,8 @@ static void ds1wm_down(struct ds1wm_data *ds1wm_data)
         ds1wm_write_register(ds1wm_data, DS1WM_INT_EN,
                              ds1wm_data->active_high ? DS1WM_INTEN_IAS : 0);
 
-        if (ds1wm_data->pdata->disable)
-                ds1wm_data->pdata->disable(ds1wm_data->pdev);
-
-        clk_disable(ds1wm_data->clk);
+        if (ds1wm_data->cell->disable)
+                ds1wm_data->cell->disable(ds1wm_data->pdev);
 }
 
 /* --------------------------------------------------------------------- */
@@ -330,13 +327,18 @@ static struct w1_bus_master ds1wm_master = {
 static int ds1wm_probe(struct platform_device *pdev)
 {
         struct ds1wm_data *ds1wm_data;
-        struct ds1wm_platform_data *plat;
+        struct ds1wm_driver_data *plat;
         struct resource *res;
+        struct mfd_cell *cell;
         int ret;
 
         if (!pdev)
                 return -ENODEV;
 
+        cell = pdev->dev.platform_data;
+        if (!cell)
+                return -ENODEV;
+
         ds1wm_data = kzalloc(sizeof(*ds1wm_data), GFP_KERNEL);
         if (!ds1wm_data)
                 return -ENOMEM;
@@ -348,15 +350,18 @@ static int ds1wm_probe(struct platform_device *pdev)
                 ret = -ENXIO;
                 goto err0;
         }
-        ds1wm_data->map = ioremap(res->start, res->end - res->start + 1);
+        ds1wm_data->map = ioremap(res->start, resource_size(res));
         if (!ds1wm_data->map) {
                 ret = -ENOMEM;
                 goto err0;
         }
-        plat = pdev->dev.platform_data;
-        ds1wm_data->bus_shift = plat->bus_shift;
+        plat = cell->driver_data;
+
+        /* calculate bus shift from mem resource */
+        ds1wm_data->bus_shift = resource_size(res) >> 3;
+
         ds1wm_data->pdev = pdev;
-        ds1wm_data->pdata = plat;
+        ds1wm_data->cell = cell;
 
         res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
         if (!res) {
@@ -376,26 +381,18 @@ static int ds1wm_probe(struct platform_device *pdev)
         if (ret)
                 goto err1;
 
-        ds1wm_data->clk = clk_get(&pdev->dev, "ds1wm");
-        if (IS_ERR(ds1wm_data->clk)) {
-                ret = PTR_ERR(ds1wm_data->clk);
-                goto err2;
-        }
-
         ds1wm_up(ds1wm_data);
 
         ds1wm_master.data = (void *)ds1wm_data;
 
         ret = w1_add_master_device(&ds1wm_master);
         if (ret)
-                goto err3;
+                goto err2;
 
         return 0;
 
-err3:
-        ds1wm_down(ds1wm_data);
-        clk_put(ds1wm_data->clk);
 err2:
+        ds1wm_down(ds1wm_data);
         free_irq(ds1wm_data->irq, ds1wm_data);
 err1:
         iounmap(ds1wm_data->map);
@@ -434,7 +431,6 @@ static int ds1wm_remove(struct platform_device *pdev)
 
         w1_remove_master_device(&ds1wm_master);
         ds1wm_down(ds1wm_data);
-        clk_put(ds1wm_data->clk);
         free_irq(ds1wm_data->irq, ds1wm_data);
         iounmap(ds1wm_data->map);
         kfree(ds1wm_data);
diff --git a/drivers/w1/masters/mxc_w1.c b/drivers/w1/masters/mxc_w1.c
index b9d74d0b353e..65244c02551b 100644
--- a/drivers/w1/masters/mxc_w1.c
+++ b/drivers/w1/masters/mxc_w1.c
@@ -116,7 +116,7 @@ static int __init mxc_w1_probe(struct platform_device *pdev)
         if (!mdev)
                 return -ENOMEM;
 
-        mdev->clk = clk_get(&pdev->dev, "owire_clk");
+        mdev->clk = clk_get(&pdev->dev, "owire");
         if (!mdev->clk) {
                 err = -ENODEV;
                 goto failed_clk;
diff --git a/drivers/w1/masters/omap_hdq.c b/drivers/w1/masters/omap_hdq.c
index c973889110c8..a7e3b706b9d3 100644
--- a/drivers/w1/masters/omap_hdq.c
+++ b/drivers/w1/masters/omap_hdq.c
@@ -590,8 +590,8 @@ static int __init omap_hdq_probe(struct platform_device *pdev)
         }
 
         /* get interface & functional clock objects */
-        hdq_data->hdq_ick = clk_get(&pdev->dev, "hdq_ick");
-        hdq_data->hdq_fck = clk_get(&pdev->dev, "hdq_fck");
+        hdq_data->hdq_ick = clk_get(&pdev->dev, "ick");
+        hdq_data->hdq_fck = clk_get(&pdev->dev, "fck");
 
         if (IS_ERR(hdq_data->hdq_ick) || IS_ERR(hdq_data->hdq_fck)) {
                 dev_dbg(&pdev->dev, "Can't get HDQ clock objects\n");
diff --git a/drivers/w1/masters/w1-gpio.c b/drivers/w1/masters/w1-gpio.c
index 9e1138a75e8b..a411702413d6 100644
--- a/drivers/w1/masters/w1-gpio.c
+++ b/drivers/w1/masters/w1-gpio.c
@@ -39,7 +39,7 @@ static u8 w1_gpio_read_bit(void *data)
 {
         struct w1_gpio_platform_data *pdata = data;
 
-        return gpio_get_value(pdata->pin);
+        return gpio_get_value(pdata->pin) ? 1 : 0;
 }
 
 static int __init w1_gpio_probe(struct platform_device *pdev)
diff --git a/drivers/w1/slaves/Kconfig b/drivers/w1/slaves/Kconfig
index 8d0b1fb1e52e..1f51366417b9 100644
--- a/drivers/w1/slaves/Kconfig
+++ b/drivers/w1/slaves/Kconfig
@@ -16,6 +16,12 @@ config W1_SLAVE_SMEM
           Say Y here if you want to connect 1-wire
           simple 64bit memory rom(ds2401/ds2411/ds1990*) to your wire.
 
+config W1_SLAVE_DS2431
+        tristate "1kb EEPROM family support (DS2431)"
+        help
+          Say Y here if you want to use a 1-wire
+          1kb EEPROM family device (DS2431)
+
 config W1_SLAVE_DS2433
         tristate "4kb EEPROM family support (DS2433)"
         help
diff --git a/drivers/w1/slaves/Makefile b/drivers/w1/slaves/Makefile
index 990f400b6d22..f1f51f19b129 100644
--- a/drivers/w1/slaves/Makefile
+++ b/drivers/w1/slaves/Makefile
@@ -4,6 +4,7 @@
 
 obj-$(CONFIG_W1_SLAVE_THERM)    += w1_therm.o
 obj-$(CONFIG_W1_SLAVE_SMEM)     += w1_smem.o
+obj-$(CONFIG_W1_SLAVE_DS2431)   += w1_ds2431.o
 obj-$(CONFIG_W1_SLAVE_DS2433)   += w1_ds2433.o
 obj-$(CONFIG_W1_SLAVE_DS2760)   += w1_ds2760.o
 obj-$(CONFIG_W1_SLAVE_BQ27000)  += w1_bq27000.o
diff --git a/drivers/w1/slaves/w1_ds2433.c b/drivers/w1/slaves/w1_ds2433.c
index 858c16a544c2..139447148822 100644
--- a/drivers/w1/slaves/w1_ds2433.c
+++ b/drivers/w1/slaves/w1_ds2433.c
@@ -156,6 +156,9 @@ out_up:
  */
 static int w1_f23_write(struct w1_slave *sl, int addr, int len, const u8 *data)
 {
+#ifdef CONFIG_W1_SLAVE_DS2433_CRC
+        struct w1_f23_data *f23 = sl->family_data;
+#endif
         u8 wrbuf[4];
         u8 rdbuf[W1_PAGE_SIZE + 3];
         u8 es = (addr + len - 1) & 0x1f;
@@ -196,7 +199,9 @@ static int w1_f23_write(struct w1_slave *sl, int addr, int len, const u8 *data)
 
         /* Reset the bus to wake up the EEPROM (this may not be needed) */
         w1_reset_bus(sl->master);
-
+#ifdef CONFIG_W1_SLAVE_DS2433_CRC
+        f23->validcrc &= ~(1 << (addr >> W1_PAGE_BITS));
+#endif
         return 0;
 }
 
diff --git a/drivers/w1/slaves/w1_therm.c b/drivers/w1/slaves/w1_therm.c
index 2c8dff9f77da..1ed3d554e372 100644
--- a/drivers/w1/slaves/w1_therm.c
+++ b/drivers/w1/slaves/w1_therm.c
@@ -115,7 +115,7 @@ static struct w1_therm_family_converter w1_therm_families[] = {
 
 static inline int w1_DS18B20_convert_temp(u8 rom[9])
 {
-        s16 t = (rom[1] << 8) | rom[0];
+        int t = ((s16)rom[1] << 8) | rom[0];
         t = t*1000/16;
         return t;
 }
diff --git a/drivers/w1/w1_io.c b/drivers/w1/w1_io.c
index 442bd8bbd4a5..3ebe9726a9e5 100644
--- a/drivers/w1/w1_io.c
+++ b/drivers/w1/w1_io.c
@@ -69,7 +69,7 @@ static u8 w1_touch_bit(struct w1_master *dev, int bit)
                 return w1_read_bit(dev);
         else {
                 w1_write_bit(dev, 0);
-                return(0);
+                return 0;
         }
 }
 
@@ -184,17 +184,17 @@ static u8 w1_read_bit(struct w1_master *dev)
  */
 u8 w1_triplet(struct w1_master *dev, int bdir)
 {
-        if ( dev->bus_master->triplet )
-                return(dev->bus_master->triplet(dev->bus_master->data, bdir));
+        if (dev->bus_master->triplet)
+                return dev->bus_master->triplet(dev->bus_master->data, bdir);
         else {
                 u8 id_bit   = w1_touch_bit(dev, 1);
                 u8 comp_bit = w1_touch_bit(dev, 1);
                 u8 retval;
 
-                if ( id_bit && comp_bit )
-                        return(0x03);  /* error */
+                if (id_bit && comp_bit)
+                        return 0x03;  /* error */
 
-                if ( !id_bit && !comp_bit ) {
+                if (!id_bit && !comp_bit) {
                         /* Both bits are valid, take the direction given */
                         retval = bdir ? 0x04 : 0;
                 } else {
@@ -203,11 +203,11 @@ u8 w1_triplet(struct w1_master *dev, int bdir)
                         retval = id_bit ? 0x05 : 0x02;
                 }
 
-                if ( dev->bus_master->touch_bit )
+                if (dev->bus_master->touch_bit)
                         w1_touch_bit(dev, bdir);
                 else
                         w1_write_bit(dev, bdir);
-                return(retval);
+                return retval;
         }
 }