W1: feature, enable hardware strong pullup

Add a strong pullup option to the w1 system.  This supplies extra power
for parasite powered devices.  There is a w1_master_pullup sysfs entry and
enable_pullup module parameter to enable or disable the strong pullup.

The one wire bus requires at a minimum one wire and ground.  The common
wire is used for sending and receiving data as well as supplying power to
devices that are parasite powered of which temperature sensors can be one
example.  The bus must be idle and left high while a temperature
conversion is in progress, in addition the normal pullup resister on
larger networks or even higher temperatures might not supply enough power.
 The pullup resister can't provide too much pullup current, because
devices need to pull the bus down to write a value.  This enables the
strong pullup for supported hardware, which can supply more current when
requested.  Unsupported hardware will just delay with the bus high.

The hardware USB 2490 one wire bus master has a bit on some commands which
will enable the strong pullup as soon as the command finishes executing.
To use strong pullup, call the new w1_next_pullup function to register the
duration.  The next write command will call set_pullup before sending the
data, and reset the duration to zero once it returns.

Switched from simple_strtol to strict_strtol.

Signed-off-by: David Fries <david@fries.net>
Cc: Evgeniy Polyakov <johnpol@2ka.mipt.ru>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

1 files changed, 64 insertions, 4 deletions

diff --git a/drivers/w1/w1_io.c b/drivers/w1/w1_io.c
index 0056ef69009b..97b338a16abc 100644
--- a/drivers/w1/w1_io.c
+++ b/drivers/w1/w1_io.c
@@ -93,6 +93,40 @@ static void w1_write_bit(struct w1_master *dev, int bit)
 }
 
 /**
+ * Pre-write operation, currently only supporting strong pullups.
+ * Program the hardware for a strong pullup, if one has been requested and
+ * the hardware supports it.
+ *
+ * @param dev     the master device
+ */
+static void w1_pre_write(struct w1_master *dev)
+{
+        if (dev->pullup_duration &&
+                dev->enable_pullup && dev->bus_master->set_pullup) {
+                dev->bus_master->set_pullup(dev->bus_master->data,
+                        dev->pullup_duration);
+        }
+}
+
+/**
+ * Post-write operation, currently only supporting strong pullups.
+ * If a strong pullup was requested, clear it if the hardware supports
+ * them, or execute the delay otherwise, in either case clear the request.
+ *
+ * @param dev     the master device
+ */
+static void w1_post_write(struct w1_master *dev)
+{
+        if (dev->pullup_duration) {
+                if (dev->enable_pullup && dev->bus_master->set_pullup)
+                        dev->bus_master->set_pullup(dev->bus_master->data, 0);
+                else
+                        msleep(dev->pullup_duration);
+                dev->pullup_duration = 0;
+        }
+}
+
+/**
  * Writes 8 bits.
  *
  * @param dev     the master device
@@ -102,11 +136,17 @@ void w1_write_8(struct w1_master *dev, u8 byte)
 {
         int i;
 
-        if (dev->bus_master->write_byte)
+        if (dev->bus_master->write_byte) {
+                w1_pre_write(dev);
                 dev->bus_master->write_byte(dev->bus_master->data, byte);
+        }
         else
-                for (i = 0; i < 8; ++i)
+                for (i = 0; i < 8; ++i) {
+                        if (i == 7)
+                                w1_pre_write(dev);
                         w1_touch_bit(dev, (byte >> i) & 0x1);
+                }
+        w1_post_write(dev);
 }
 EXPORT_SYMBOL_GPL(w1_write_8);
 
@@ -203,11 +243,14 @@ void w1_write_block(struct w1_master *dev, const u8 *buf, int len)
 {
         int i;
 
-        if (dev->bus_master->write_block)
+        if (dev->bus_master->write_block) {
+                w1_pre_write(dev);
                 dev->bus_master->write_block(dev->bus_master->data, buf, len);
+        }
         else
                 for (i = 0; i < len; ++i)
-                        w1_write_8(dev, buf[i]);
+                        w1_write_8(dev, buf[i]); /* calls w1_pre_write */
+        w1_post_write(dev);
 }
 EXPORT_SYMBOL_GPL(w1_write_block);
 
@@ -306,3 +349,20 @@ int w1_reset_select_slave(struct w1_slave *sl)
         return 0;
 }
 EXPORT_SYMBOL_GPL(w1_reset_select_slave);
+
+/**
+ * Put out a strong pull-up of the specified duration after the next write
+ * operation.  Not all hardware supports strong pullups.  Hardware that
+ * doesn't support strong pullups will sleep for the given time after the
+ * write operation without a strong pullup.  This is a one shot request for
+ * the next write, specifying zero will clear a previous request.
+ * The w1 master lock must be held.
+ *
+ * @param delay time in milliseconds
+ * @return      0=success, anything else=error
+ */
+void w1_next_pullup(struct w1_master *dev, int delay)
+{
+        dev->pullup_duration = delay;
+}
+EXPORT_SYMBOL_GPL(w1_next_pullup);