Merge branch 'linus' into release

9 files changed, 488 insertions, 57 deletions

diff --git a/drivers/w1/masters/Kconfig b/drivers/w1/masters/Kconfig
index 90616822cd2..96d2f8e4c27 100644
--- a/drivers/w1/masters/Kconfig
+++ b/drivers/w1/masters/Kconfig
@@ -34,6 +34,12 @@ config W1_MASTER_DS2482
           This driver can also be built as a module.  If so, the module
           will be called ds2482.
 
+config W1_MASTER_MXC
+        tristate "Freescale MXC 1-wire busmaster"
+        depends on W1 && ARCH_MXC
+        help
+          Say Y here to enable MXC 1-wire host
+
 config W1_MASTER_DS1WM
         tristate "Maxim DS1WM 1-wire busmaster"
         depends on W1 && ARM && HAVE_CLK
diff --git a/drivers/w1/masters/Makefile b/drivers/w1/masters/Makefile
index bc4714a75f3..c5a3e96fcba 100644
--- a/drivers/w1/masters/Makefile
+++ b/drivers/w1/masters/Makefile
@@ -5,6 +5,8 @@
 obj-$(CONFIG_W1_MASTER_MATROX)          += matrox_w1.o
 obj-$(CONFIG_W1_MASTER_DS2490)          += ds2490.o
 obj-$(CONFIG_W1_MASTER_DS2482)          += ds2482.o
+obj-$(CONFIG_W1_MASTER_MXC)             += mxc_w1.o
+
 obj-$(CONFIG_W1_MASTER_DS1WM)           += ds1wm.o
 obj-$(CONFIG_W1_MASTER_GPIO)            += w1-gpio.o
 obj-$(CONFIG_HDQ_MASTER_OMAP)           += omap_hdq.o
diff --git a/drivers/w1/masters/mxc_w1.c b/drivers/w1/masters/mxc_w1.c
new file mode 100644
index 00000000000..b9d74d0b353
--- /dev/null
+++ b/drivers/w1/masters/mxc_w1.c
@@ -0,0 +1,211 @@
+/*
+ * Copyright 2005-2008 Freescale Semiconductor, Inc. All Rights Reserved.
+ * Copyright 2008 Luotao Fu, kernel@pengutronix.de
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+#include <linux/delay.h>
+#include <linux/io.h>
+
+#include "../w1.h"
+#include "../w1_int.h"
+#include "../w1_log.h"
+
+/* According to the mx27 Datasheet the reset procedure should take up to about
+ * 1350us. We set the timeout to 500*100us = 50ms for sure */
+#define MXC_W1_RESET_TIMEOUT 500
+
+/*
+ * MXC W1 Register offsets
+ */
+#define MXC_W1_CONTROL          0x00
+#define MXC_W1_TIME_DIVIDER     0x02
+#define MXC_W1_RESET            0x04
+#define MXC_W1_COMMAND          0x06
+#define MXC_W1_TXRX             0x08
+#define MXC_W1_INTERRUPT        0x0A
+#define MXC_W1_INTERRUPT_EN     0x0C
+
+struct mxc_w1_device {
+        void __iomem *regs;
+        unsigned int clkdiv;
+        struct clk *clk;
+        struct w1_bus_master bus_master;
+};
+
+/*
+ * this is the low level routine to
+ * reset the device on the One Wire interface
+ * on the hardware
+ */
+static u8 mxc_w1_ds2_reset_bus(void *data)
+{
+        u8 reg_val;
+        unsigned int timeout_cnt = 0;
+        struct mxc_w1_device *dev = data;
+
+        __raw_writeb(0x80, (dev->regs + MXC_W1_CONTROL));
+
+        while (1) {
+                reg_val = __raw_readb(dev->regs + MXC_W1_CONTROL);
+
+                if (((reg_val >> 7) & 0x1) == 0 ||
+                    timeout_cnt > MXC_W1_RESET_TIMEOUT)
+                        break;
+                else
+                        timeout_cnt++;
+
+                udelay(100);
+        }
+        return (reg_val >> 7) & 0x1;
+}
+
+/*
+ * this is the low level routine to read/write a bit on the One Wire
+ * interface on the hardware. It does write 0 if parameter bit is set
+ * to 0, otherwise a write 1/read.
+ */
+static u8 mxc_w1_ds2_touch_bit(void *data, u8 bit)
+{
+        struct mxc_w1_device *mdev = data;
+        void __iomem *ctrl_addr = mdev->regs + MXC_W1_CONTROL;
+        unsigned int timeout_cnt = 400; /* Takes max. 120us according to
+                                         * datasheet.
+                                         */
+
+        __raw_writeb((1 << (5 - bit)), ctrl_addr);
+
+        while (timeout_cnt--) {
+                if (!((__raw_readb(ctrl_addr) >> (5 - bit)) & 0x1))
+                        break;
+
+                udelay(1);
+        }
+
+        return ((__raw_readb(ctrl_addr)) >> 3) & 0x1;
+}
+
+static int __init mxc_w1_probe(struct platform_device *pdev)
+{
+        struct mxc_w1_device *mdev;
+        struct resource *res;
+        int err = 0;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res)
+                return -ENODEV;
+
+        mdev = kzalloc(sizeof(struct mxc_w1_device), GFP_KERNEL);
+        if (!mdev)
+                return -ENOMEM;
+
+        mdev->clk = clk_get(&pdev->dev, "owire_clk");
+        if (!mdev->clk) {
+                err = -ENODEV;
+                goto failed_clk;
+        }
+
+        mdev->clkdiv = (clk_get_rate(mdev->clk) / 1000000) - 1;
+
+        res = request_mem_region(res->start, resource_size(res),
+                                "mxc_w1");
+        if (!res) {
+                err = -EBUSY;
+                goto failed_req;
+        }
+
+        mdev->regs = ioremap(res->start, resource_size(res));
+        if (!mdev->regs) {
+                printk(KERN_ERR "Cannot map frame buffer registers\n");
+                goto failed_ioremap;
+        }
+
+        clk_enable(mdev->clk);
+        __raw_writeb(mdev->clkdiv, mdev->regs + MXC_W1_TIME_DIVIDER);
+
+        mdev->bus_master.data = mdev;
+        mdev->bus_master.reset_bus = mxc_w1_ds2_reset_bus;
+        mdev->bus_master.touch_bit = mxc_w1_ds2_touch_bit;
+
+        err = w1_add_master_device(&mdev->bus_master);
+
+        if (err)
+                goto failed_add;
+
+        platform_set_drvdata(pdev, mdev);
+        return 0;
+
+failed_add:
+        iounmap(mdev->regs);
+failed_ioremap:
+        release_mem_region(res->start, resource_size(res));
+failed_req:
+        clk_put(mdev->clk);
+failed_clk:
+        kfree(mdev);
+        return err;
+}
+
+/*
+ * disassociate the w1 device from the driver
+ */
+static int mxc_w1_remove(struct platform_device *pdev)
+{
+        struct mxc_w1_device *mdev = platform_get_drvdata(pdev);
+        struct resource *res;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+
+        w1_remove_master_device(&mdev->bus_master);
+
+        iounmap(mdev->regs);
+        release_mem_region(res->start, resource_size(res));
+        clk_disable(mdev->clk);
+        clk_put(mdev->clk);
+
+        platform_set_drvdata(pdev, NULL);
+
+        return 0;
+}
+
+static struct platform_driver mxc_w1_driver = {
+        .driver = {
+                   .name = "mxc_w1",
+        },
+        .probe = mxc_w1_probe,
+        .remove = mxc_w1_remove,
+};
+
+static int __init mxc_w1_init(void)
+{
+        return platform_driver_register(&mxc_w1_driver);
+}
+
+static void mxc_w1_exit(void)
+{
+        platform_driver_unregister(&mxc_w1_driver);
+}
+
+module_init(mxc_w1_init);
+module_exit(mxc_w1_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Freescale Semiconductors Inc");
+MODULE_DESCRIPTION("Driver for One-Wire on MXC");
diff --git a/drivers/w1/w1.c b/drivers/w1/w1.c
index 3b615d4022e..acc7e3b7fe1 100644
--- a/drivers/w1/w1.c
+++ b/drivers/w1/w1.c
@@ -197,7 +197,7 @@ struct device_driver w1_master_driver = {
 struct device w1_master_device = {
         .parent = NULL,
         .bus = &w1_bus_type,
-        .bus_id = "w1 bus master",
+        .init_name = "w1 bus master",
         .driver = &w1_master_driver,
         .release = &w1_master_release
 };
@@ -211,7 +211,7 @@ static struct device_driver w1_slave_driver = {
 struct device w1_slave_device = {
         .parent = NULL,
         .bus = &w1_bus_type,
-        .bus_id = "w1 bus slave",
+        .init_name = "w1 bus slave",
         .driver = &w1_slave_driver,
         .release = &w1_slave_release
 };
@@ -573,7 +573,7 @@ static int w1_uevent(struct device *dev, struct kobj_uevent_env *env)
         }
 
         dev_dbg(dev, "Hotplug event for %s %s, bus_id=%s.\n",
-                        event_owner, name, dev->bus_id);
+                        event_owner, name, dev_name(dev));
 
         if (dev->driver != &w1_slave_driver || !sl)
                 return 0;
@@ -605,8 +605,7 @@ static int __w1_attach_slave_device(struct w1_slave *sl)
         sl->dev.bus = &w1_bus_type;
         sl->dev.release = &w1_slave_release;
 
-        snprintf(&sl->dev.bus_id[0], sizeof(sl->dev.bus_id),
-                 "%02x-%012llx",
+        dev_set_name(&sl->dev, "%02x-%012llx",
                  (unsigned int) sl->reg_num.family,
                  (unsigned long long) sl->reg_num.id);
         snprintf(&sl->name[0], sizeof(sl->name),
@@ -615,13 +614,13 @@ static int __w1_attach_slave_device(struct w1_slave *sl)
                  (unsigned long long) sl->reg_num.id);
 
         dev_dbg(&sl->dev, "%s: registering %s as %p.\n", __func__,
-                &sl->dev.bus_id[0], sl);
+                dev_name(&sl->dev), sl);
 
         err = device_register(&sl->dev);
         if (err < 0) {
                 dev_err(&sl->dev,
                         "Device registration [%s] failed. err=%d\n",
-                        sl->dev.bus_id, err);
+                        dev_name(&sl->dev), err);
                 return err;
         }
 
@@ -630,7 +629,7 @@ static int __w1_attach_slave_device(struct w1_slave *sl)
         if (err < 0) {
                 dev_err(&sl->dev,
                         "sysfs file creation for [%s] failed. err=%d\n",
-                        sl->dev.bus_id, err);
+                        dev_name(&sl->dev), err);
                 goto out_unreg;
         }
 
@@ -639,7 +638,7 @@ static int __w1_attach_slave_device(struct w1_slave *sl)
         if (err < 0) {
                 dev_err(&sl->dev,
                         "sysfs file creation for [%s] failed. err=%d\n",
-                        sl->dev.bus_id, err);
+                        dev_name(&sl->dev), err);
                 goto out_rem1;
         }
 
@@ -648,7 +647,7 @@ static int __w1_attach_slave_device(struct w1_slave *sl)
             ((err = sl->family->fops->add_slave(sl)) < 0)) {
                 dev_err(&sl->dev,
                         "sysfs file creation for [%s] failed. err=%d\n",
-                        sl->dev.bus_id, err);
+                        dev_name(&sl->dev), err);
                 goto out_rem2;
         }
 
diff --git a/drivers/w1/w1.h b/drivers/w1/w1.h
index 97304bd83ec..d8a9709f344 100644
--- a/drivers/w1/w1.h
+++ b/drivers/w1/w1.h
@@ -210,6 +210,7 @@ u8 w1_read_8(struct w1_master *);
 int w1_reset_bus(struct w1_master *);
 u8 w1_calc_crc8(u8 *, int);
 void w1_write_block(struct w1_master *, const u8 *, int);
+void w1_touch_block(struct w1_master *, u8 *, int);
 u8 w1_read_block(struct w1_master *, u8 *, int);
 int w1_reset_select_slave(struct w1_slave *sl);
 void w1_next_pullup(struct w1_master *, int);
diff --git a/drivers/w1/w1_int.c b/drivers/w1/w1_int.c
index a3a54567bfb..4a46ed58ece 100644
--- a/drivers/w1/w1_int.c
+++ b/drivers/w1/w1_int.c
@@ -75,8 +75,7 @@ static struct w1_master * w1_alloc_dev(u32 id, int slave_count, int slave_ttl,
         mutex_init(&dev->mutex);
 
         memcpy(&dev->dev, device, sizeof(struct device));
-        snprintf(dev->dev.bus_id, sizeof(dev->dev.bus_id),
-                  "w1_bus_master%u", dev->id);
+        dev_set_name(&dev->dev, "w1_bus_master%u", dev->id);
         snprintf(dev->name, sizeof(dev->name), "w1_bus_master%u", dev->id);
 
         dev->driver = driver;
diff --git a/drivers/w1/w1_io.c b/drivers/w1/w1_io.c
index 5139c25ca96..442bd8bbd4a 100644
--- a/drivers/w1/w1_io.c
+++ b/drivers/w1/w1_io.c
@@ -238,7 +238,6 @@ EXPORT_SYMBOL_GPL(w1_read_8);
  * @param dev     the master device
  * @param buf     pointer to the data to write
  * @param len     the number of bytes to write
- * @return        the byte read
  */
 void w1_write_block(struct w1_master *dev, const u8 *buf, int len)
 {
@@ -256,6 +255,31 @@ void w1_write_block(struct w1_master *dev, const u8 *buf, int len)
 EXPORT_SYMBOL_GPL(w1_write_block);
 
 /**
+ * Touches a series of bytes.
+ *
+ * @param dev     the master device
+ * @param buf     pointer to the data to write
+ * @param len     the number of bytes to write
+ */
+void w1_touch_block(struct w1_master *dev, u8 *buf, int len)
+{
+        int i, j;
+        u8 tmp;
+
+        for (i = 0; i < len; ++i) {
+                tmp = 0;
+                for (j = 0; j < 8; ++j) {
+                        if (j == 7)
+                                w1_pre_write(dev);
+                        tmp |= w1_touch_bit(dev, (buf[i] >> j) & 0x1) << j;
+                }
+
+                buf[i] = tmp;
+        }
+}
+EXPORT_SYMBOL_GPL(w1_touch_block);
+
+/**
  * Reads a series of bytes.
  *
  * @param dev     the master device
diff --git a/drivers/w1/w1_netlink.c b/drivers/w1/w1_netlink.c
index 65c5ebd0787..fdf72851c57 100644
--- a/drivers/w1/w1_netlink.c
+++ b/drivers/w1/w1_netlink.c
@@ -47,21 +47,56 @@ void w1_netlink_send(struct w1_master *dev, struct w1_netlink_msg *msg)
         cn_netlink_send(m, 0, GFP_KERNEL);
 }
 
-static int w1_process_command_master(struct w1_master *dev, struct cn_msg *msg,
-                struct w1_netlink_msg *hdr, struct w1_netlink_cmd *cmd)
+static void w1_send_slave(struct w1_master *dev, u64 rn)
+{
+        struct cn_msg *msg = dev->priv;
+        struct w1_netlink_msg *hdr = (struct w1_netlink_msg *)(msg + 1);
+        struct w1_netlink_cmd *cmd = (struct w1_netlink_cmd *)(hdr + 1);
+        int avail;
+
+        avail = dev->priv_size - cmd->len;
+
+        if (avail > 8) {
+                u64 *data = (void *)(cmd + 1) + cmd->len;
+
+                *data = rn;
+                cmd->len += 8;
+                hdr->len += 8;
+                msg->len += 8;
+                return;
+        }
+
+        msg->ack++;
+        cn_netlink_send(msg, 0, GFP_KERNEL);
+
+        msg->len = sizeof(struct w1_netlink_msg) + sizeof(struct w1_netlink_cmd);
+        hdr->len = sizeof(struct w1_netlink_cmd);
+        cmd->len = 0;
+}
+
+static int w1_process_search_command(struct w1_master *dev, struct cn_msg *msg,
+                unsigned int avail)
 {
-        dev_dbg(&dev->dev, "%s: %s: cmd=%02x, len=%u.\n",
-                __func__, dev->name, cmd->cmd, cmd->len);
+        struct w1_netlink_msg *hdr = (struct w1_netlink_msg *)(msg + 1);
+        struct w1_netlink_cmd *cmd = (struct w1_netlink_cmd *)(hdr + 1);
+        int search_type = (cmd->cmd == W1_CMD_ALARM_SEARCH)?W1_ALARM_SEARCH:W1_SEARCH;
 
-        if (cmd->cmd != W1_CMD_SEARCH && cmd->cmd != W1_CMD_ALARM_SEARCH)
-                return -EINVAL;
+        dev->priv = msg;
+        dev->priv_size = avail;
+
+        w1_search_devices(dev, search_type, w1_send_slave);
+
+        msg->ack = 0;
+        cn_netlink_send(msg, 0, GFP_KERNEL);
+
+        dev->priv = NULL;
+        dev->priv_size = 0;
 
-        w1_search_process(dev, (cmd->cmd == W1_CMD_ALARM_SEARCH)?W1_ALARM_SEARCH:W1_SEARCH);
         return 0;
 }
 
-static int w1_send_read_reply(struct w1_slave *sl, struct cn_msg *msg,
-                struct w1_netlink_msg *hdr, struct w1_netlink_cmd *cmd)
+static int w1_send_read_reply(struct cn_msg *msg, struct w1_netlink_msg *hdr,
+                struct w1_netlink_cmd *cmd)
 {
         void *data;
         struct w1_netlink_msg *h;
@@ -85,7 +120,8 @@ static int w1_send_read_reply(struct w1_slave *sl, struct cn_msg *msg,
         memcpy(c, cmd, sizeof(struct w1_netlink_cmd));
 
         cm->ack = msg->seq+1;
-        cm->len = sizeof(struct w1_netlink_msg) + sizeof(struct w1_netlink_cmd) + cmd->len;
+        cm->len = sizeof(struct w1_netlink_msg) +
+                sizeof(struct w1_netlink_cmd) + cmd->len;
 
         h->len = sizeof(struct w1_netlink_cmd) + cmd->len;
 
@@ -98,36 +134,178 @@ static int w1_send_read_reply(struct w1_slave *sl, struct cn_msg *msg,
         return err;
 }
 
-static int w1_process_command_slave(struct w1_slave *sl, struct cn_msg *msg,
+static int w1_process_command_io(struct w1_master *dev, struct cn_msg *msg,
                 struct w1_netlink_msg *hdr, struct w1_netlink_cmd *cmd)
 {
         int err = 0;
 
-        dev_dbg(&sl->master->dev, "%s: %02x.%012llx.%02x: cmd=%02x, len=%u.\n",
-                __func__, sl->reg_num.family, (unsigned long long)sl->reg_num.id, sl->reg_num.crc,
-                cmd->cmd, cmd->len);
+        switch (cmd->cmd) {
+        case W1_CMD_TOUCH:
+                w1_touch_block(dev, cmd->data, cmd->len);
+                w1_send_read_reply(msg, hdr, cmd);
+                break;
+        case W1_CMD_READ:
+                w1_read_block(dev, cmd->data, cmd->len);
+                w1_send_read_reply(msg, hdr, cmd);
+                break;
+        case W1_CMD_WRITE:
+                w1_write_block(dev, cmd->data, cmd->len);
+                break;
+        default:
+                err = -EINVAL;
+                break;
+        }
+
+        return err;
+}
+
+static int w1_process_command_master(struct w1_master *dev, struct cn_msg *req_msg,
+                struct w1_netlink_msg *req_hdr, struct w1_netlink_cmd *req_cmd)
+{
+        int err = -EINVAL;
+        struct cn_msg *msg;
+        struct w1_netlink_msg *hdr;
+        struct w1_netlink_cmd *cmd;
+
+        msg = kzalloc(PAGE_SIZE, GFP_KERNEL);
+        if (!msg)
+                return -ENOMEM;
+
+        msg->id = req_msg->id;
+        msg->seq = req_msg->seq;
+        msg->ack = 0;
+        msg->len = sizeof(struct w1_netlink_msg) + sizeof(struct w1_netlink_cmd);
+
+        hdr = (struct w1_netlink_msg *)(msg + 1);
+        cmd = (struct w1_netlink_cmd *)(hdr + 1);
+
+        hdr->type = W1_MASTER_CMD;
+        hdr->id = req_hdr->id;
+        hdr->len = sizeof(struct w1_netlink_cmd);
+
+        cmd->cmd = req_cmd->cmd;
+        cmd->len = 0;
 
         switch (cmd->cmd) {
-                case W1_CMD_READ:
-                        w1_read_block(sl->master, cmd->data, cmd->len);
-                        w1_send_read_reply(sl, msg, hdr, cmd);
-                        break;
-                case W1_CMD_WRITE:
-                        w1_write_block(sl->master, cmd->data, cmd->len);
-                        break;
-                case W1_CMD_SEARCH:
-                case W1_CMD_ALARM_SEARCH:
-                        w1_search_process(sl->master,
-                                        (cmd->cmd == W1_CMD_ALARM_SEARCH)?W1_ALARM_SEARCH:W1_SEARCH);
-                        break;
-                default:
-                        err = -1;
-                        break;
+        case W1_CMD_SEARCH:
+        case W1_CMD_ALARM_SEARCH:
+                err = w1_process_search_command(dev, msg,
+                                PAGE_SIZE - msg->len - sizeof(struct cn_msg));
+                break;
+        case W1_CMD_READ:
+        case W1_CMD_WRITE:
+        case W1_CMD_TOUCH:
+                err = w1_process_command_io(dev, req_msg, req_hdr, req_cmd);
+                break;
+        case W1_CMD_RESET:
+                err = w1_reset_bus(dev);
+                break;
+        default:
+                err = -EINVAL;
+                break;
         }
 
+        kfree(msg);
         return err;
 }
 
+static int w1_process_command_slave(struct w1_slave *sl, struct cn_msg *msg,
+                struct w1_netlink_msg *hdr, struct w1_netlink_cmd *cmd)
+{
+        dev_dbg(&sl->master->dev, "%s: %02x.%012llx.%02x: cmd=%02x, len=%u.\n",
+                __func__, sl->reg_num.family, (unsigned long long)sl->reg_num.id,
+                sl->reg_num.crc, cmd->cmd, cmd->len);
+
+        return w1_process_command_io(sl->master, msg, hdr, cmd);
+}
+
+static int w1_process_command_root(struct cn_msg *msg, struct w1_netlink_msg *mcmd)
+{
+        struct w1_master *m;
+        struct cn_msg *cn;
+        struct w1_netlink_msg *w;
+        u32 *id;
+
+        if (mcmd->type != W1_LIST_MASTERS) {
+                printk(KERN_NOTICE "%s: msg: %x.%x, wrong type: %u, len: %u.\n",
+                        __func__, msg->id.idx, msg->id.val, mcmd->type, mcmd->len);
+                return -EPROTO;
+        }
+
+        cn = kmalloc(PAGE_SIZE, GFP_KERNEL);
+        if (!cn)
+                return -ENOMEM;
+
+        cn->id.idx = CN_W1_IDX;
+        cn->id.val = CN_W1_VAL;
+
+        cn->seq = msg->seq;
+        cn->ack = 1;
+        cn->len = sizeof(struct w1_netlink_msg);
+        w = (struct w1_netlink_msg *)(cn + 1);
+
+        w->type = W1_LIST_MASTERS;
+        w->status = 0;
+        w->len = 0;
+        id = (u32 *)(w + 1);
+
+        mutex_lock(&w1_mlock);
+        list_for_each_entry(m, &w1_masters, w1_master_entry) {
+                if (cn->len + sizeof(*id) > PAGE_SIZE - sizeof(struct cn_msg)) {
+                        cn_netlink_send(cn, 0, GFP_KERNEL);
+                        cn->ack++;
+                        cn->len = sizeof(struct w1_netlink_msg);
+                        w->len = 0;
+                        id = (u32 *)(w + 1);
+                }
+
+                *id = m->id;
+                w->len += sizeof(*id);
+                cn->len += sizeof(*id);
+                id++;
+        }
+        cn->ack = 0;
+        cn_netlink_send(cn, 0, GFP_KERNEL);
+        mutex_unlock(&w1_mlock);
+
+        kfree(cn);
+        return 0;
+}
+
+static int w1_netlink_send_error(struct cn_msg *rcmsg, struct w1_netlink_msg *rmsg,
+                struct w1_netlink_cmd *rcmd, int error)
+{
+        struct cn_msg *cmsg;
+        struct w1_netlink_msg *msg;
+        struct w1_netlink_cmd *cmd;
+
+        cmsg = kzalloc(sizeof(*msg) + sizeof(*cmd) + sizeof(*cmsg), GFP_KERNEL);
+        if (!cmsg)
+                return -ENOMEM;
+
+        msg = (struct w1_netlink_msg *)(cmsg + 1);
+        cmd = (struct w1_netlink_cmd *)(msg + 1);
+
+        memcpy(cmsg, rcmsg, sizeof(*cmsg));
+        cmsg->len = sizeof(*msg);
+
+        memcpy(msg, rmsg, sizeof(*msg));
+        msg->len = 0;
+        msg->status = (short)-error;
+
+        if (rcmd) {
+                memcpy(cmd, rcmd, sizeof(*cmd));
+                cmd->len = 0;
+                msg->len += sizeof(*cmd);
+                cmsg->len += sizeof(*cmd);
+        }
+
+        error = cn_netlink_send(cmsg, 0, GFP_KERNEL);
+        kfree(cmsg);
+
+        return error;
+}
+
 static void w1_cn_callback(void *data)
 {
         struct cn_msg *msg = data;
@@ -144,6 +322,7 @@ static void w1_cn_callback(void *data)
 
                 dev = NULL;
                 sl = NULL;
+                cmd = NULL;
 
                 memcpy(&id, m->id.id, sizeof(id));
 #if 0
@@ -155,15 +334,15 @@ static void w1_cn_callback(void *data)
                         break;
                 }
 
-                if (!mlen)
-                        goto out_cont;
-
                 if (m->type == W1_MASTER_CMD) {
                         dev = w1_search_master_id(m->id.mst.id);
                 } else if (m->type == W1_SLAVE_CMD) {
                         sl = w1_search_slave(&id);
                         if (sl)
                                 dev = sl->master;
+                } else {
+                        err = w1_process_command_root(msg, m);
+                        goto out_cont;
                 }
 
                 if (!dev) {
@@ -171,6 +350,10 @@ static void w1_cn_callback(void *data)
                         goto out_cont;
                 }
 
+                err = 0;
+                if (!mlen)
+                        goto out_cont;
+
                 mutex_lock(&dev->mutex);
 
                 if (sl && w1_reset_select_slave(sl)) {
@@ -187,9 +370,12 @@ static void w1_cn_callback(void *data)
                         }
 
                         if (sl)
-                                w1_process_command_slave(sl, msg, m, cmd);
+                                err = w1_process_command_slave(sl, msg, m, cmd);
                         else
-                                w1_process_command_master(dev, msg, m, cmd);
+                                err = w1_process_command_master(dev, msg, m, cmd);
+
+                        w1_netlink_send_error(msg, m, cmd, err);
+                        err = 0;
 
                         cmd_data += cmd->len + sizeof(struct w1_netlink_cmd);
                         mlen -= cmd->len + sizeof(struct w1_netlink_cmd);
@@ -200,6 +386,8 @@ out_up:
                         atomic_dec(&sl->refcnt);
                 mutex_unlock(&dev->mutex);
 out_cont:
+                if (!cmd || err)
+                        w1_netlink_send_error(msg, m, cmd, err);
                 msg->len -= sizeof(struct w1_netlink_msg) + m->len;
                 m = (struct w1_netlink_msg *)(((u8 *)m) + sizeof(struct w1_netlink_msg) + m->len);
 
@@ -209,11 +397,6 @@ out_cont:
                 if (err == -ENODEV)
                         err = 0;
         }
-#if 0
-        if (err) {
-                printk("%s: malformed message. Dropping.\n", __func__);
-        }
-#endif
 }
 
 int w1_init_netlink(void)
diff --git a/drivers/w1/w1_netlink.h b/drivers/w1/w1_netlink.h
index 56122b9e929..27e950f935b 100644
--- a/drivers/w1/w1_netlink.h
+++ b/drivers/w1/w1_netlink.h
@@ -34,12 +34,13 @@ enum w1_netlink_message_types {
         W1_MASTER_REMOVE,
         W1_MASTER_CMD,
         W1_SLAVE_CMD,
+        W1_LIST_MASTERS,
 };
 
 struct w1_netlink_msg
 {
         __u8                            type;
-        __u8                            reserved;
+        __u8                            status;
         __u16                           len;
         union {
                 __u8                    id[8];
@@ -51,10 +52,15 @@ struct w1_netlink_msg
         __u8                            data[0];
 };
 
-#define W1_CMD_READ             0x0
-#define W1_CMD_WRITE            0x1
-#define W1_CMD_SEARCH           0x2
-#define W1_CMD_ALARM_SEARCH     0x3
+enum w1_commands {
+        W1_CMD_READ = 0,
+        W1_CMD_WRITE,
+        W1_CMD_SEARCH,
+        W1_CMD_ALARM_SEARCH,
+        W1_CMD_TOUCH,
+        W1_CMD_RESET,
+        W1_CMD_MAX,
+};
 
 struct w1_netlink_cmd
 {