44 files changed, 1537 insertions, 1057 deletions

diff --git a/drivers/char/agp/Kconfig b/drivers/char/agp/Kconfig
index 7c88c060a9e6..46685a540772 100644
--- a/drivers/char/agp/Kconfig
+++ b/drivers/char/agp/Kconfig
@@ -1,7 +1,6 @@
 config AGP
-        tristate "/dev/agpgart (AGP Support)" if !GART_IOMMU
+        tristate "/dev/agpgart (AGP Support)"
         depends on ALPHA || IA64 || PPC || X86
-        default y if GART_IOMMU
         ---help---
           AGP (Accelerated Graphics Port) is a bus system mainly used to
           connect graphics cards to the rest of the system.
diff --git a/drivers/net/myri10ge/myri10ge.c b/drivers/net/myri10ge/myri10ge.c
index e1feb58bd661..1a2b9785e998 100644
--- a/drivers/net/myri10ge/myri10ge.c
+++ b/drivers/net/myri10ge/myri10ge.c
@@ -2120,7 +2120,7 @@ abort_linearize:
                 goto drop;
         }
 
-        if (skb_linearize(skb, GFP_ATOMIC))
+        if (skb_linearize(skb))
                 goto drop;
 
         mgp->tx_linearized++;
diff --git a/drivers/pci/Makefile b/drivers/pci/Makefile
index 6707df968934..f2d152b818f0 100644
--- a/drivers/pci/Makefile
+++ b/drivers/pci/Makefile
@@ -26,7 +26,11 @@ obj-$(CONFIG_PPC32) += setup-irq.o
 obj-$(CONFIG_PPC64) += setup-bus.o
 obj-$(CONFIG_MIPS) += setup-bus.o setup-irq.o
 obj-$(CONFIG_X86_VISWS) += setup-irq.o
-obj-$(CONFIG_PCI_MSI) += msi.o
+
+msiobj-y := msi.o msi-apic.o
+msiobj-$(CONFIG_IA64_GENERIC) += msi-altix.o
+msiobj-$(CONFIG_IA64_SGI_SN2) += msi-altix.o
+obj-$(CONFIG_PCI_MSI) += $(msiobj-y)
 
 #
 # ACPI Related PCI FW Functions
diff --git a/drivers/pci/bus.c b/drivers/pci/bus.c
index eed67d9e73bc..723092682023 100644
--- a/drivers/pci/bus.c
+++ b/drivers/pci/bus.c
@@ -81,9 +81,9 @@ void __devinit pci_bus_add_device(struct pci_dev *dev)
 {
         device_add(&dev->dev);
 
-        spin_lock(&pci_bus_lock);
+        down_write(&pci_bus_sem);
         list_add_tail(&dev->global_list, &pci_devices);
-        spin_unlock(&pci_bus_lock);
+        up_write(&pci_bus_sem);
 
         pci_proc_attach_device(dev);
         pci_create_sysfs_dev_files(dev);
@@ -125,10 +125,10 @@ void __devinit pci_bus_add_devices(struct pci_bus *bus)
                  */
                 if (dev->subordinate) {
                        if (list_empty(&dev->subordinate->node)) {
-                               spin_lock(&pci_bus_lock);
+                               down_write(&pci_bus_sem);
                                list_add_tail(&dev->subordinate->node,
                                                &dev->bus->children);
-                               spin_unlock(&pci_bus_lock);
+                               up_write(&pci_bus_sem);
                        }
                         pci_bus_add_devices(dev->subordinate);
 
@@ -168,7 +168,7 @@ void pci_walk_bus(struct pci_bus *top, void (*cb)(struct pci_dev *, void *),
         struct list_head *next;
 
         bus = top;
-        spin_lock(&pci_bus_lock);
+        down_read(&pci_bus_sem);
         next = top->devices.next;
         for (;;) {
                 if (next == &bus->devices) {
@@ -180,22 +180,19 @@ void pci_walk_bus(struct pci_bus *top, void (*cb)(struct pci_dev *, void *),
                         continue;
                 }
                 dev = list_entry(next, struct pci_dev, bus_list);
-                pci_dev_get(dev);
                 if (dev->subordinate) {
                         /* this is a pci-pci bridge, do its devices next */
                         next = dev->subordinate->devices.next;
                         bus = dev->subordinate;
                 } else
                         next = dev->bus_list.next;
-                spin_unlock(&pci_bus_lock);
 
-                /* Run device routines with the bus unlocked */
+                /* Run device routines with the device locked */
+                down(&dev->dev.sem);
                 cb(dev, userdata);
-
-                spin_lock(&pci_bus_lock);
-                pci_dev_put(dev);
+                up(&dev->dev.sem);
         }
-        spin_unlock(&pci_bus_lock);
+        up_read(&pci_bus_sem);
 }
 EXPORT_SYMBOL_GPL(pci_walk_bus);
 
diff --git a/drivers/pci/msi-altix.c b/drivers/pci/msi-altix.c
new file mode 100644
index 000000000000..bed4183a5e39
--- /dev/null
+++ b/drivers/pci/msi-altix.c
@@ -0,0 +1,210 @@
+/*
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ * Copyright (C) 2006 Silicon Graphics, Inc.  All Rights Reserved.
+ */
+
+#include <linux/types.h>
+#include <linux/pci.h>
+#include <linux/cpumask.h>
+
+#include <asm/sn/addrs.h>
+#include <asm/sn/intr.h>
+#include <asm/sn/pcibus_provider_defs.h>
+#include <asm/sn/pcidev.h>
+#include <asm/sn/nodepda.h>
+
+#include "msi.h"
+
+struct sn_msi_info {
+        u64 pci_addr;
+        struct sn_irq_info *sn_irq_info;
+};
+
+static struct sn_msi_info *sn_msi_info;
+
+static void
+sn_msi_teardown(unsigned int vector)
+{
+        nasid_t nasid;
+        int widget;
+        struct pci_dev *pdev;
+        struct pcidev_info *sn_pdev;
+        struct sn_irq_info *sn_irq_info;
+        struct pcibus_bussoft *bussoft;
+        struct sn_pcibus_provider *provider;
+
+        sn_irq_info = sn_msi_info[vector].sn_irq_info;
+        if (sn_irq_info == NULL || sn_irq_info->irq_int_bit >= 0)
+                return;
+
+        sn_pdev = (struct pcidev_info *)sn_irq_info->irq_pciioinfo;
+        pdev = sn_pdev->pdi_linux_pcidev;
+        provider = SN_PCIDEV_BUSPROVIDER(pdev);
+
+        (*provider->dma_unmap)(pdev,
+                               sn_msi_info[vector].pci_addr,
+                               PCI_DMA_FROMDEVICE);
+        sn_msi_info[vector].pci_addr = 0;
+
+        bussoft = SN_PCIDEV_BUSSOFT(pdev);
+        nasid = NASID_GET(bussoft->bs_base);
+        widget = (nasid & 1) ?
+                        TIO_SWIN_WIDGETNUM(bussoft->bs_base) :
+                        SWIN_WIDGETNUM(bussoft->bs_base);
+
+        sn_intr_free(nasid, widget, sn_irq_info);
+        sn_msi_info[vector].sn_irq_info = NULL;
+
+        return;
+}
+
+int
+sn_msi_setup(struct pci_dev *pdev, unsigned int vector,
+             u32 *addr_hi, u32 *addr_lo, u32 *data)
+{
+        int widget;
+        int status;
+        nasid_t nasid;
+        u64 bus_addr;
+        struct sn_irq_info *sn_irq_info;
+        struct pcibus_bussoft *bussoft = SN_PCIDEV_BUSSOFT(pdev);
+        struct sn_pcibus_provider *provider = SN_PCIDEV_BUSPROVIDER(pdev);
+
+        if (bussoft == NULL)
+                return -EINVAL;
+
+        if (provider == NULL || provider->dma_map_consistent == NULL)
+                return -EINVAL;
+
+        /*
+         * Set up the vector plumbing.  Let the prom (via sn_intr_alloc)
+         * decide which cpu to direct this msi at by default.
+         */
+
+        nasid = NASID_GET(bussoft->bs_base);
+        widget = (nasid & 1) ?
+                        TIO_SWIN_WIDGETNUM(bussoft->bs_base) :
+                        SWIN_WIDGETNUM(bussoft->bs_base);
+
+        sn_irq_info = kzalloc(sizeof(struct sn_irq_info), GFP_KERNEL);
+        if (! sn_irq_info)
+                return -ENOMEM;
+
+        status = sn_intr_alloc(nasid, widget, sn_irq_info, vector, -1, -1);
+        if (status) {
+                kfree(sn_irq_info);
+                return -ENOMEM;
+        }
+
+        sn_irq_info->irq_int_bit = -1;          /* mark this as an MSI irq */
+        sn_irq_fixup(pdev, sn_irq_info);
+
+        /* Prom probably should fill these in, but doesn't ... */
+        sn_irq_info->irq_bridge_type = bussoft->bs_asic_type;
+        sn_irq_info->irq_bridge = (void *)bussoft->bs_base;
+
+        /*
+         * Map the xio address into bus space
+         */
+        bus_addr = (*provider->dma_map_consistent)(pdev,
+                                        sn_irq_info->irq_xtalkaddr,
+                                        sizeof(sn_irq_info->irq_xtalkaddr),
+                                        SN_DMA_MSI|SN_DMA_ADDR_XIO);
+        if (! bus_addr) {
+                sn_intr_free(nasid, widget, sn_irq_info);
+                kfree(sn_irq_info);
+                return -ENOMEM;
+        }
+
+        sn_msi_info[vector].sn_irq_info = sn_irq_info;
+        sn_msi_info[vector].pci_addr = bus_addr;
+
+        *addr_hi = (u32)(bus_addr >> 32);
+        *addr_lo = (u32)(bus_addr & 0x00000000ffffffff);
+
+        /*
+         * In the SN platform, bit 16 is a "send vector" bit which
+         * must be present in order to move the vector through the system.
+         */
+        *data = 0x100 + (unsigned int)vector;
+
+#ifdef CONFIG_SMP
+        set_irq_affinity_info((vector & 0xff), sn_irq_info->irq_cpuid, 0);
+#endif
+
+        return 0;
+}
+
+static void
+sn_msi_target(unsigned int vector, unsigned int cpu,
+              u32 *addr_hi, u32 *addr_lo)
+{
+        int slice;
+        nasid_t nasid;
+        u64 bus_addr;
+        struct pci_dev *pdev;
+        struct pcidev_info *sn_pdev;
+        struct sn_irq_info *sn_irq_info;
+        struct sn_irq_info *new_irq_info;
+        struct sn_pcibus_provider *provider;
+
+        sn_irq_info = sn_msi_info[vector].sn_irq_info;
+        if (sn_irq_info == NULL || sn_irq_info->irq_int_bit >= 0)
+                return;
+
+        /*
+         * Release XIO resources for the old MSI PCI address
+         */
+
+        sn_pdev = (struct pcidev_info *)sn_irq_info->irq_pciioinfo;
+        pdev = sn_pdev->pdi_linux_pcidev;
+        provider = SN_PCIDEV_BUSPROVIDER(pdev);
+
+        bus_addr = (u64)(*addr_hi) << 32 | (u64)(*addr_lo);
+        (*provider->dma_unmap)(pdev, bus_addr, PCI_DMA_FROMDEVICE);
+        sn_msi_info[vector].pci_addr = 0;
+
+        nasid = cpuid_to_nasid(cpu);
+        slice = cpuid_to_slice(cpu);
+
+        new_irq_info = sn_retarget_vector(sn_irq_info, nasid, slice);
+        sn_msi_info[vector].sn_irq_info = new_irq_info;
+        if (new_irq_info == NULL)
+                return;
+
+        /*
+         * Map the xio address into bus space
+         */
+
+        bus_addr = (*provider->dma_map_consistent)(pdev,
+                                        new_irq_info->irq_xtalkaddr,
+                                        sizeof(new_irq_info->irq_xtalkaddr),
+                                        SN_DMA_MSI|SN_DMA_ADDR_XIO);
+
+        sn_msi_info[vector].pci_addr = bus_addr;
+        *addr_hi = (u32)(bus_addr >> 32);
+        *addr_lo = (u32)(bus_addr & 0x00000000ffffffff);
+}
+
+struct msi_ops sn_msi_ops = {
+        .setup = sn_msi_setup,
+        .teardown = sn_msi_teardown,
+#ifdef CONFIG_SMP
+        .target = sn_msi_target,
+#endif
+};
+
+int
+sn_msi_init(void)
+{
+        sn_msi_info =
+                kzalloc(sizeof(struct sn_msi_info) * NR_VECTORS, GFP_KERNEL);
+        if (! sn_msi_info)
+                return -ENOMEM;
+
+        msi_register(&sn_msi_ops);
+        return 0;
+}
diff --git a/drivers/pci/msi-apic.c b/drivers/pci/msi-apic.c
new file mode 100644
index 000000000000..0eb5fe9003a2
--- /dev/null
+++ b/drivers/pci/msi-apic.c
@@ -0,0 +1,100 @@
+/*
+ * MSI hooks for standard x86 apic
+ */
+
+#include <linux/pci.h>
+#include <linux/irq.h>
+
+#include "msi.h"
+
+/*
+ * Shifts for APIC-based data
+ */
+
+#define MSI_DATA_VECTOR_SHIFT           0
+#define     MSI_DATA_VECTOR(v)          (((u8)v) << MSI_DATA_VECTOR_SHIFT)
+
+#define MSI_DATA_DELIVERY_SHIFT         8
+#define     MSI_DATA_DELIVERY_FIXED     (0 << MSI_DATA_DELIVERY_SHIFT)
+#define     MSI_DATA_DELIVERY_LOWPRI    (1 << MSI_DATA_DELIVERY_SHIFT)
+
+#define MSI_DATA_LEVEL_SHIFT            14
+#define     MSI_DATA_LEVEL_DEASSERT     (0 << MSI_DATA_LEVEL_SHIFT)
+#define     MSI_DATA_LEVEL_ASSERT       (1 << MSI_DATA_LEVEL_SHIFT)
+
+#define MSI_DATA_TRIGGER_SHIFT          15
+#define     MSI_DATA_TRIGGER_EDGE       (0 << MSI_DATA_TRIGGER_SHIFT)
+#define     MSI_DATA_TRIGGER_LEVEL      (1 << MSI_DATA_TRIGGER_SHIFT)
+
+/*
+ * Shift/mask fields for APIC-based bus address
+ */
+
+#define MSI_ADDR_HEADER                 0xfee00000
+
+#define MSI_ADDR_DESTID_MASK            0xfff0000f
+#define     MSI_ADDR_DESTID_CPU(cpu)    ((cpu) << MSI_TARGET_CPU_SHIFT)
+
+#define MSI_ADDR_DESTMODE_SHIFT         2
+#define     MSI_ADDR_DESTMODE_PHYS      (0 << MSI_ADDR_DESTMODE_SHIFT)
+#define     MSI_ADDR_DESTMODE_LOGIC     (1 << MSI_ADDR_DESTMODE_SHIFT)
+
+#define MSI_ADDR_REDIRECTION_SHIFT      3
+#define     MSI_ADDR_REDIRECTION_CPU    (0 << MSI_ADDR_REDIRECTION_SHIFT)
+#define     MSI_ADDR_REDIRECTION_LOWPRI (1 << MSI_ADDR_REDIRECTION_SHIFT)
+
+
+static void
+msi_target_apic(unsigned int vector,
+                unsigned int dest_cpu,
+                u32 *address_hi,        /* in/out */
+                u32 *address_lo)        /* in/out */
+{
+        u32 addr = *address_lo;
+
+        addr &= MSI_ADDR_DESTID_MASK;
+        addr |= MSI_ADDR_DESTID_CPU(cpu_physical_id(dest_cpu));
+
+        *address_lo = addr;
+}
+
+static int
+msi_setup_apic(struct pci_dev *pdev,    /* unused in generic */
+                unsigned int vector,
+                u32 *address_hi,
+                u32 *address_lo,
+                u32 *data)
+{
+        unsigned long   dest_phys_id;
+
+        dest_phys_id = cpu_physical_id(first_cpu(cpu_online_map));
+
+        *address_hi = 0;
+        *address_lo =   MSI_ADDR_HEADER |
+                        MSI_ADDR_DESTMODE_PHYS |
+                        MSI_ADDR_REDIRECTION_CPU |
+                        MSI_ADDR_DESTID_CPU(dest_phys_id);
+
+        *data = MSI_DATA_TRIGGER_EDGE |
+                MSI_DATA_LEVEL_ASSERT |
+                MSI_DATA_DELIVERY_FIXED |
+                MSI_DATA_VECTOR(vector);
+
+        return 0;
+}
+
+static void
+msi_teardown_apic(unsigned int vector)
+{
+        return;         /* no-op */
+}
+
+/*
+ * Generic ops used on most IA archs/platforms.  Set with msi_register()
+ */
+
+struct msi_ops msi_apic_ops = {
+        .setup = msi_setup_apic,
+        .teardown = msi_teardown_apic,
+        .target = msi_target_apic,
+};
diff --git a/drivers/pci/msi.c b/drivers/pci/msi.c
index 9855c4c920b8..7f8429284fab 100644
--- a/drivers/pci/msi.c
+++ b/drivers/pci/msi.c
@@ -23,8 +23,6 @@
 #include "pci.h"
 #include "msi.h"
 
-#define MSI_TARGET_CPU          first_cpu(cpu_online_map)
-
 static DEFINE_SPINLOCK(msi_lock);
 static struct msi_desc* msi_desc[NR_IRQS] = { [0 ... NR_IRQS-1] = NULL };
 static kmem_cache_t* msi_cachep;
@@ -37,9 +35,17 @@ static int nr_msix_devices;
 
 #ifndef CONFIG_X86_IO_APIC
 int vector_irq[NR_VECTORS] = { [0 ... NR_VECTORS - 1] = -1};
-u8 irq_vector[NR_IRQ_VECTORS] = { FIRST_DEVICE_VECTOR , 0 };
 #endif
 
+static struct msi_ops *msi_ops;
+
+int
+msi_register(struct msi_ops *ops)
+{
+        msi_ops = ops;
+        return 0;
+}
+
 static void msi_cache_ctor(void *p, kmem_cache_t *cache, unsigned long flags)
 {
         memset(p, 0, NR_IRQS * sizeof(struct msi_desc));
@@ -92,7 +98,7 @@ static void msi_set_mask_bit(unsigned int vector, int flag)
 static void set_msi_affinity(unsigned int vector, cpumask_t cpu_mask)
 {
         struct msi_desc *entry;
-        struct msg_address address;
+        u32 address_hi, address_lo;
         unsigned int irq = vector;
         unsigned int dest_cpu = first_cpu(cpu_mask);
 
@@ -108,28 +114,36 @@ static void set_msi_affinity(unsigned int vector, cpumask_t cpu_mask)
                 if (!pos)
                         return;
 
+                pci_read_config_dword(entry->dev, msi_upper_address_reg(pos),
+                        &address_hi);
                 pci_read_config_dword(entry->dev, msi_lower_address_reg(pos),
-                        &address.lo_address.value);
-                address.lo_address.value &= MSI_ADDRESS_DEST_ID_MASK;
-                address.lo_address.value |= (cpu_physical_id(dest_cpu) <<
-                                                                        MSI_TARGET_CPU_SHIFT);
-                entry->msi_attrib.current_cpu = cpu_physical_id(dest_cpu);
+                        &address_lo);
+
+                msi_ops->target(vector, dest_cpu, &address_hi, &address_lo);
+
+                pci_write_config_dword(entry->dev, msi_upper_address_reg(pos),
+                        address_hi);
                 pci_write_config_dword(entry->dev, msi_lower_address_reg(pos),
-                        address.lo_address.value);
+                        address_lo);
                 set_native_irq_info(irq, cpu_mask);
                 break;
         }
         case PCI_CAP_ID_MSIX:
         {
-                int offset = entry->msi_attrib.entry_nr * PCI_MSIX_ENTRY_SIZE +
-                        PCI_MSIX_ENTRY_LOWER_ADDR_OFFSET;
-
-                address.lo_address.value = readl(entry->mask_base + offset);
-                address.lo_address.value &= MSI_ADDRESS_DEST_ID_MASK;
-                address.lo_address.value |= (cpu_physical_id(dest_cpu) <<
-                                                                        MSI_TARGET_CPU_SHIFT);
-                entry->msi_attrib.current_cpu = cpu_physical_id(dest_cpu);
-                writel(address.lo_address.value, entry->mask_base + offset);
+                int offset_hi =
+                        entry->msi_attrib.entry_nr * PCI_MSIX_ENTRY_SIZE +
+                                PCI_MSIX_ENTRY_UPPER_ADDR_OFFSET;
+                int offset_lo =
+                        entry->msi_attrib.entry_nr * PCI_MSIX_ENTRY_SIZE +
+                                PCI_MSIX_ENTRY_LOWER_ADDR_OFFSET;
+
+                address_hi = readl(entry->mask_base + offset_hi);
+                address_lo = readl(entry->mask_base + offset_lo);
+
+                msi_ops->target(vector, dest_cpu, &address_hi, &address_lo);
+
+                writel(address_hi, entry->mask_base + offset_hi);
+                writel(address_lo, entry->mask_base + offset_lo);
                 set_native_irq_info(irq, cpu_mask);
                 break;
         }
@@ -251,30 +265,6 @@ static struct hw_interrupt_type msi_irq_wo_maskbit_type = {
         .set_affinity   = set_msi_affinity
 };
 
-static void msi_data_init(struct msg_data *msi_data,
-                          unsigned int vector)
-{
-        memset(msi_data, 0, sizeof(struct msg_data));
-        msi_data->vector = (u8)vector;
-        msi_data->delivery_mode = MSI_DELIVERY_MODE;
-        msi_data->level = MSI_LEVEL_MODE;
-        msi_data->trigger = MSI_TRIGGER_MODE;
-}
-
-static void msi_address_init(struct msg_address *msi_address)
-{
-        unsigned int    dest_id;
-        unsigned long   dest_phys_id = cpu_physical_id(MSI_TARGET_CPU);
-
-        memset(msi_address, 0, sizeof(struct msg_address));
-        msi_address->hi_address = (u32)0;
-        dest_id = (MSI_ADDRESS_HEADER << MSI_ADDRESS_HEADER_SHIFT);
-        msi_address->lo_address.u.dest_mode = MSI_PHYSICAL_MODE;
-        msi_address->lo_address.u.redirection_hint = MSI_REDIRECTION_HINT_MODE;
-        msi_address->lo_address.u.dest_id = dest_id;
-        msi_address->lo_address.value |= (dest_phys_id << MSI_TARGET_CPU_SHIFT);
-}
-
 static int msi_free_vector(struct pci_dev* dev, int vector, int reassign);
 static int assign_msi_vector(void)
 {
@@ -369,13 +359,29 @@ static int msi_init(void)
                 return status;
         }
 
+        status = msi_arch_init();
+        if (status < 0) {
+                pci_msi_enable = 0;
+                printk(KERN_WARNING
+                       "PCI: MSI arch init failed.  MSI disabled.\n");
+                return status;
+        }
+
+        if (! msi_ops) {
+                printk(KERN_WARNING
+                       "PCI: MSI ops not registered. MSI disabled.\n");
+                status = -EINVAL;
+                return status;
+        }
+
+        last_alloc_vector = assign_irq_vector(AUTO_ASSIGN);
         status = msi_cache_init();
         if (status < 0) {
                 pci_msi_enable = 0;
                 printk(KERN_WARNING "PCI: MSI cache init failed\n");
                 return status;
         }
-        last_alloc_vector = assign_irq_vector(AUTO_ASSIGN);
+
         if (last_alloc_vector < 0) {
                 pci_msi_enable = 0;
                 printk(KERN_WARNING "PCI: No interrupt vectors available for MSI\n");
@@ -442,9 +448,11 @@ static void enable_msi_mode(struct pci_dev *dev, int pos, int type)
                 /* Set enabled bits to single MSI & enable MSI_enable bit */
                 msi_enable(control, 1);
                 pci_write_config_word(dev, msi_control_reg(pos), control);
+                dev->msi_enabled = 1;
         } else {
                 msix_enable(control);
                 pci_write_config_word(dev, msi_control_reg(pos), control);
+                dev->msix_enabled = 1;
         }
         if (pci_find_capability(dev, PCI_CAP_ID_EXP)) {
                 /* PCI Express Endpoint device detected */
@@ -461,9 +469,11 @@ void disable_msi_mode(struct pci_dev *dev, int pos, int type)
                 /* Set enabled bits to single MSI & enable MSI_enable bit */
                 msi_disable(control);
                 pci_write_config_word(dev, msi_control_reg(pos), control);
+                dev->msi_enabled = 0;
         } else {
                 msix_disable(control);
                 pci_write_config_word(dev, msi_control_reg(pos), control);
+                dev->msix_enabled = 0;
         }
         if (pci_find_capability(dev, PCI_CAP_ID_EXP)) {
                 /* PCI Express Endpoint device detected */
@@ -538,7 +548,6 @@ int pci_save_msi_state(struct pci_dev *dev)
                 pci_read_config_dword(dev, pos + PCI_MSI_DATA_32, &cap[i++]);
         if (control & PCI_MSI_FLAGS_MASKBIT)
                 pci_read_config_dword(dev, pos + PCI_MSI_MASK_BIT, &cap[i++]);
-        disable_msi_mode(dev, pos, PCI_CAP_ID_MSI);
         save_state->cap_nr = PCI_CAP_ID_MSI;
         pci_add_saved_cap(dev, save_state);
         return 0;
@@ -575,6 +584,8 @@ void pci_restore_msi_state(struct pci_dev *dev)
 int pci_save_msix_state(struct pci_dev *dev)
 {
         int pos;
+        int temp;
+        int vector, head, tail = 0;
         u16 control;
         struct pci_cap_saved_state *save_state;
 
@@ -582,6 +593,7 @@ int pci_save_msix_state(struct pci_dev *dev)
         if (pos <= 0 || dev->no_msi)
                 return 0;
 
+        /* save the capability */
         pci_read_config_word(dev, msi_control_reg(pos), &control);
         if (!(control & PCI_MSIX_FLAGS_ENABLE))
                 return 0;
@@ -593,7 +605,38 @@ int pci_save_msix_state(struct pci_dev *dev)
         }
         *((u16 *)&save_state->data[0]) = control;
 
-        disable_msi_mode(dev, pos, PCI_CAP_ID_MSIX);
+        /* save the table */
+        temp = dev->irq;
+        if (msi_lookup_vector(dev, PCI_CAP_ID_MSIX)) {
+                kfree(save_state);
+                return -EINVAL;
+        }
+
+        vector = head = dev->irq;
+        while (head != tail) {
+                int j;
+                void __iomem *base;
+                struct msi_desc *entry;
+
+                entry = msi_desc[vector];
+                base = entry->mask_base;
+                j = entry->msi_attrib.entry_nr;
+
+                entry->address_lo_save =
+                        readl(base + j * PCI_MSIX_ENTRY_SIZE +
+                              PCI_MSIX_ENTRY_LOWER_ADDR_OFFSET);
+                entry->address_hi_save =
+                        readl(base + j * PCI_MSIX_ENTRY_SIZE +
+                              PCI_MSIX_ENTRY_UPPER_ADDR_OFFSET);
+                entry->data_save =
+                        readl(base + j * PCI_MSIX_ENTRY_SIZE +
+                              PCI_MSIX_ENTRY_DATA_OFFSET);
+
+                tail = msi_desc[vector]->link.tail;
+                vector = tail;
+        }
+        dev->irq = temp;
+
         save_state->cap_nr = PCI_CAP_ID_MSIX;
         pci_add_saved_cap(dev, save_state);
         return 0;
@@ -606,8 +649,6 @@ void pci_restore_msix_state(struct pci_dev *dev)
         int vector, head, tail = 0;
         void __iomem *base;
         int j;
-        struct msg_address address;
-        struct msg_data data;
         struct msi_desc *entry;
         int temp;
         struct pci_cap_saved_state *save_state;
@@ -633,20 +674,13 @@ void pci_restore_msix_state(struct pci_dev *dev)
                 base = entry->mask_base;
                 j = entry->msi_attrib.entry_nr;
 
-                msi_address_init(&address);
-                msi_data_init(&data, vector);
-
-                address.lo_address.value &= MSI_ADDRESS_DEST_ID_MASK;
-                address.lo_address.value |= entry->msi_attrib.current_cpu <<
-                                        MSI_TARGET_CPU_SHIFT;
-
-                writel(address.lo_address.value,
+                writel(entry->address_lo_save,
                         base + j * PCI_MSIX_ENTRY_SIZE +
                         PCI_MSIX_ENTRY_LOWER_ADDR_OFFSET);
-                writel(address.hi_address,
+                writel(entry->address_hi_save,
                         base + j * PCI_MSIX_ENTRY_SIZE +
                         PCI_MSIX_ENTRY_UPPER_ADDR_OFFSET);
-                writel(*(u32*)&data,
+                writel(entry->data_save,
                         base + j * PCI_MSIX_ENTRY_SIZE +
                         PCI_MSIX_ENTRY_DATA_OFFSET);
 
@@ -660,30 +694,32 @@ void pci_restore_msix_state(struct pci_dev *dev)
 }
 #endif
 
-static void msi_register_init(struct pci_dev *dev, struct msi_desc *entry)
+static int msi_register_init(struct pci_dev *dev, struct msi_desc *entry)
 {
-        struct msg_address address;
-        struct msg_data data;
+        int status;
+        u32 address_hi;
+        u32 address_lo;
+        u32 data;
         int pos, vector = dev->irq;
         u16 control;
 
         pos = pci_find_capability(dev, PCI_CAP_ID_MSI);
         pci_read_config_word(dev, msi_control_reg(pos), &control);
+
         /* Configure MSI capability structure */
-        msi_address_init(&address);
-        msi_data_init(&data, vector);
-        entry->msi_attrib.current_cpu = ((address.lo_address.u.dest_id >>
-                                MSI_TARGET_CPU_SHIFT) & MSI_TARGET_CPU_MASK);
-        pci_write_config_dword(dev, msi_lower_address_reg(pos),
-                        address.lo_address.value);
+        status = msi_ops->setup(dev, vector, &address_hi, &address_lo, &data);
+        if (status < 0)
+                return status;
+
+        pci_write_config_dword(dev, msi_lower_address_reg(pos), address_lo);
         if (is_64bit_address(control)) {
                 pci_write_config_dword(dev,
-                        msi_upper_address_reg(pos), address.hi_address);
+                        msi_upper_address_reg(pos), address_hi);
                 pci_write_config_word(dev,
-                        msi_data_reg(pos, 1), *((u32*)&data));
+                        msi_data_reg(pos, 1), data);
         } else
                 pci_write_config_word(dev,
-                        msi_data_reg(pos, 0), *((u32*)&data));
+                        msi_data_reg(pos, 0), data);
         if (entry->msi_attrib.maskbit) {
                 unsigned int maskbits, temp;
                 /* All MSIs are unmasked by default, Mask them all */
@@ -697,6 +733,8 @@ static void msi_register_init(struct pci_dev *dev, struct msi_desc *entry)
                         msi_mask_bits_reg(pos, is_64bit_address(control)),
                         maskbits);
         }
+
+        return 0;
 }
 
 /**
@@ -710,6 +748,7 @@ static void msi_register_init(struct pci_dev *dev, struct msi_desc *entry)
  **/
 static int msi_capability_init(struct pci_dev *dev)
 {
+        int status;
         struct msi_desc *entry;
         int pos, vector;
         u16 control;
@@ -742,7 +781,12 @@ static int msi_capability_init(struct pci_dev *dev)
         /* Replace with MSI handler */
         irq_handler_init(PCI_CAP_ID_MSI, vector, entry->msi_attrib.maskbit);
         /* Configure MSI capability structure */
-        msi_register_init(dev, entry);
+        status = msi_register_init(dev, entry);
+        if (status != 0) {
+                dev->irq = entry->msi_attrib.default_vector;
+                kmem_cache_free(msi_cachep, entry);
+                return status;
+        }
 
         attach_msi_entry(entry, vector);
         /* Set MSI enabled bits  */
@@ -765,8 +809,10 @@ static int msix_capability_init(struct pci_dev *dev,
                                 struct msix_entry *entries, int nvec)
 {
         struct msi_desc *head = NULL, *tail = NULL, *entry = NULL;
-        struct msg_address address;
-        struct msg_data data;
+        u32 address_hi;
+        u32 address_lo;
+        u32 data;
+        int status;
         int vector, pos, i, j, nr_entries, temp = 0;
         unsigned long phys_addr;
         u32 table_offset;
@@ -822,18 +868,20 @@ static int msix_capability_init(struct pci_dev *dev,
                 /* Replace with MSI-X handler */
                 irq_handler_init(PCI_CAP_ID_MSIX, vector, 1);
                 /* Configure MSI-X capability structure */
-                msi_address_init(&address);
-                msi_data_init(&data, vector);
-                entry->msi_attrib.current_cpu =
-                        ((address.lo_address.u.dest_id >>
-                        MSI_TARGET_CPU_SHIFT) & MSI_TARGET_CPU_MASK);
-                writel(address.lo_address.value,
+                status = msi_ops->setup(dev, vector,
+                                        &address_hi,
+                                        &address_lo,
+                                        &data);
+                if (status < 0)
+                        break;
+
+                writel(address_lo,
                         base + j * PCI_MSIX_ENTRY_SIZE +
                         PCI_MSIX_ENTRY_LOWER_ADDR_OFFSET);
-                writel(address.hi_address,
+                writel(address_hi,
                         base + j * PCI_MSIX_ENTRY_SIZE +
                         PCI_MSIX_ENTRY_UPPER_ADDR_OFFSET);
-                writel(*(u32*)&data,
+                writel(data,
                         base + j * PCI_MSIX_ENTRY_SIZE +
                         PCI_MSIX_ENTRY_DATA_OFFSET);
                 attach_msi_entry(entry, vector);
@@ -865,6 +913,7 @@ static int msix_capability_init(struct pci_dev *dev,
  **/
 int pci_enable_msi(struct pci_dev* dev)
 {
+        struct pci_bus *bus;
         int pos, temp, status = -EINVAL;
         u16 control;
 
@@ -874,8 +923,9 @@ int pci_enable_msi(struct pci_dev* dev)
         if (dev->no_msi)
                 return status;
 
-        if (dev->bus->bus_flags & PCI_BUS_FLAGS_NO_MSI)
-                return -EINVAL;
+        for (bus = dev->bus; bus; bus = bus->parent)
+                if (bus->bus_flags & PCI_BUS_FLAGS_NO_MSI)
+                        return -EINVAL;
 
         temp = dev->irq;
 
@@ -887,23 +937,23 @@ int pci_enable_msi(struct pci_dev* dev)
         if (!pos)
                 return -EINVAL;
 
-        pci_read_config_word(dev, msi_control_reg(pos), &control);
-        if (control & PCI_MSI_FLAGS_ENABLE)
-                return 0;                       /* Already in MSI mode */
-
         if (!msi_lookup_vector(dev, PCI_CAP_ID_MSI)) {
                 /* Lookup Sucess */
                 unsigned long flags;
 
+                pci_read_config_word(dev, msi_control_reg(pos), &control);
+                if (control & PCI_MSI_FLAGS_ENABLE)
+                        return 0;       /* Already in MSI mode */
                 spin_lock_irqsave(&msi_lock, flags);
                 if (!vector_irq[dev->irq]) {
                         msi_desc[dev->irq]->msi_attrib.state = 0;
                         vector_irq[dev->irq] = -1;
                         nr_released_vectors--;
                         spin_unlock_irqrestore(&msi_lock, flags);
-                        msi_register_init(dev, msi_desc[dev->irq]);
-                        enable_msi_mode(dev, pos, PCI_CAP_ID_MSI);
-                        return 0;
+                        status = msi_register_init(dev, msi_desc[dev->irq]);
+                        if (status == 0)
+                                enable_msi_mode(dev, pos, PCI_CAP_ID_MSI);
+                        return status;
                 }
                 spin_unlock_irqrestore(&msi_lock, flags);
                 dev->irq = temp;
@@ -980,6 +1030,8 @@ static int msi_free_vector(struct pci_dev* dev, int vector, int reassign)
         void __iomem *base;
         unsigned long flags;
 
+        msi_ops->teardown(vector);
+
         spin_lock_irqsave(&msi_lock, flags);
         entry = msi_desc[vector];
         if (!entry || entry->dev != dev) {
@@ -1008,33 +1060,8 @@ static int msi_free_vector(struct pci_dev* dev, int vector, int reassign)
                                 entry_nr * PCI_MSIX_ENTRY_SIZE +
                                 PCI_MSIX_ENTRY_VECTOR_CTRL_OFFSET);
 
-                if (head == vector) {
-                        /*
-                         * Detect last MSI-X vector to be released.
-                         * Release the MSI-X memory-mapped table.
-                         */
-#if 0
-                        int pos, nr_entries;
-                        unsigned long phys_addr;
-                        u32 table_offset;
-                        u16 control;
-                        u8 bir;
-
-                        pos = pci_find_capability(dev, PCI_CAP_ID_MSIX);
-                        pci_read_config_word(dev, msi_control_reg(pos),
-                                &control);
-                        nr_entries = multi_msix_capable(control);
-                        pci_read_config_dword(dev, msix_table_offset_reg(pos),
-                                &table_offset);
-                        bir = (u8)(table_offset & PCI_MSIX_FLAGS_BIRMASK);
-                        table_offset &= ~PCI_MSIX_FLAGS_BIRMASK;
-                        phys_addr = pci_resource_start(dev, bir) + table_offset;
-/*
- * FIXME!  and what did you want to do with phys_addr?
- */
-#endif
+                if (head == vector)
                         iounmap(base);
-                }
         }
 
         return 0;
@@ -1108,6 +1135,7 @@ static int reroute_msix_table(int head, struct msix_entry *entries, int *nvec)
  **/
 int pci_enable_msix(struct pci_dev* dev, struct msix_entry *entries, int nvec)
 {
+        struct pci_bus *bus;
         int status, pos, nr_entries, free_vectors;
         int i, j, temp;
         u16 control;
@@ -1116,6 +1144,13 @@ int pci_enable_msix(struct pci_dev* dev, struct msix_entry *entries, int nvec)
         if (!pci_msi_enable || !dev || !entries)
                 return -EINVAL;
 
+        if (dev->no_msi)
+                return -EINVAL;
+
+        for (bus = dev->bus; bus; bus = bus->parent)
+                if (bus->bus_flags & PCI_BUS_FLAGS_NO_MSI)
+                        return -EINVAL;
+
         status = msi_init();
         if (status < 0)
                 return status;
@@ -1300,24 +1335,6 @@ void msi_remove_pci_irq_vectors(struct pci_dev* dev)
                 }
                 msi_free_vector(dev, vector, 0);
                 if (warning) {
-                        /* Force to release the MSI-X memory-mapped table */
-#if 0
-                        unsigned long phys_addr;
-                        u32 table_offset;
-                        u16 control;
-                        u8 bir;
-
-                        pci_read_config_word(dev, msi_control_reg(pos),
-                                &control);
-                        pci_read_config_dword(dev, msix_table_offset_reg(pos),
-                                &table_offset);
-                        bir = (u8)(table_offset & PCI_MSIX_FLAGS_BIRMASK);
-                        table_offset &= ~PCI_MSIX_FLAGS_BIRMASK;
-                        phys_addr = pci_resource_start(dev, bir) + table_offset;
-/*
- * FIXME! and what did you want to do with phys_addr?
- */
-#endif
                         iounmap(base);
                         printk(KERN_WARNING "PCI: %s: msi_remove_pci_irq_vectors() "
                                "called without free_irq() on all MSI-X vectors\n",
diff --git a/drivers/pci/msi.h b/drivers/pci/msi.h
index 4ac52d441e47..56951c39d3a3 100644
--- a/drivers/pci/msi.h
+++ b/drivers/pci/msi.h
@@ -6,6 +6,68 @@
 #ifndef MSI_H
 #define MSI_H
 
+/*
+ * MSI operation vector.  Used by the msi core code (drivers/pci/msi.c)
+ * to abstract platform-specific tasks relating to MSI address generation
+ * and resource management.
+ */
+struct msi_ops {
+        /**
+         * setup - generate an MSI bus address and data for a given vector
+         * @pdev: PCI device context (in)
+         * @vector: vector allocated by the msi core (in)
+         * @addr_hi: upper 32 bits of PCI bus MSI address (out)
+         * @addr_lo: lower 32 bits of PCI bus MSI address (out)
+         * @data: MSI data payload (out)
+         *
+         * Description: The setup op is used to generate a PCI bus addres and
+         * data which the msi core will program into the card MSI capability
+         * registers.  The setup routine is responsible for picking an initial
+         * cpu to target the MSI at.  The setup routine is responsible for
+         * examining pdev to determine the MSI capabilities of the card and
+         * generating a suitable address/data.  The setup routine is
+         * responsible for allocating and tracking any system resources it
+         * needs to route the MSI to the cpu it picks, and for associating
+         * those resources with the passed in vector.
+         *
+         * Returns 0 if the MSI address/data was successfully setup.
+         **/
+
+        int     (*setup)    (struct pci_dev *pdev, unsigned int vector,
+                             u32 *addr_hi, u32 *addr_lo, u32 *data);
+
+        /**
+         * teardown - release resources allocated by setup
+         * @vector: vector context for resources (in)
+         *
+         * Description:  The teardown op is used to release any resources
+         * that were allocated in the setup routine associated with the passed
+         * in vector.
+         **/
+
+        void    (*teardown) (unsigned int vector);
+
+        /**
+         * target - retarget an MSI at a different cpu
+         * @vector: vector context for resources (in)
+         * @cpu:  new cpu to direct vector at (in)
+         * @addr_hi: new value of PCI bus upper 32 bits (in/out)
+         * @addr_lo: new value of PCI bus lower 32 bits (in/out)
+         *
+         * Description:  The target op is used to redirect an MSI vector
+         * at a different cpu.  addr_hi/addr_lo coming in are the existing
+         * values that the MSI core has programmed into the card.  The
+         * target code is responsible for freeing any resources (if any)
+         * associated with the old address, and generating a new PCI bus
+         * addr_hi/addr_lo that will redirect the vector at the indicated cpu.
+         **/
+
+        void    (*target)   (unsigned int vector, unsigned int cpu,
+                             u32 *addr_hi, u32 *addr_lo);
+};
+
+extern int msi_register(struct msi_ops *ops);
+
 #include <asm/msi.h>
 
 /*
@@ -63,67 +125,6 @@ extern int pci_vector_resources(int last, int nr_released);
 #define msix_mask(address)              (address | PCI_MSIX_FLAGS_BITMASK)
 #define msix_is_pending(address)        (address & PCI_MSIX_FLAGS_PENDMASK)
 
-/*
- * MSI Defined Data Structures
- */
-#define MSI_ADDRESS_HEADER              0xfee
-#define MSI_ADDRESS_HEADER_SHIFT        12
-#define MSI_ADDRESS_HEADER_MASK         0xfff000
-#define MSI_ADDRESS_DEST_ID_MASK        0xfff0000f
-#define MSI_TARGET_CPU_MASK             0xff
-#define MSI_DELIVERY_MODE               0
-#define MSI_LEVEL_MODE                  1       /* Edge always assert */
-#define MSI_TRIGGER_MODE                0       /* MSI is edge sensitive */
-#define MSI_PHYSICAL_MODE               0
-#define MSI_LOGICAL_MODE                1
-#define MSI_REDIRECTION_HINT_MODE       0
-
-struct msg_data {
-#if defined(__LITTLE_ENDIAN_BITFIELD)
-        __u32   vector          :  8;
-        __u32   delivery_mode   :  3;   /* 000b: FIXED | 001b: lowest prior */
-        __u32   reserved_1      :  3;
-        __u32   level           :  1;   /* 0: deassert | 1: assert */
-        __u32   trigger         :  1;   /* 0: edge | 1: level */
-        __u32   reserved_2      : 16;
-#elif defined(__BIG_ENDIAN_BITFIELD)
-        __u32   reserved_2      : 16;
-        __u32   trigger         :  1;   /* 0: edge | 1: level */
-        __u32   level           :  1;   /* 0: deassert | 1: assert */
-        __u32   reserved_1      :  3;
-        __u32   delivery_mode   :  3;   /* 000b: FIXED | 001b: lowest prior */
-        __u32   vector          :  8;
-#else
-#error "Bitfield endianness not defined! Check your byteorder.h"
-#endif
-} __attribute__ ((packed));
-
-struct msg_address {
-        union {
-                struct {
-#if defined(__LITTLE_ENDIAN_BITFIELD)
-                        __u32   reserved_1      :  2;
-                        __u32   dest_mode       :  1;   /*0:physic | 1:logic */
-                        __u32   redirection_hint:  1;   /*0: dedicated CPU
-                                                          1: lowest priority */
-                        __u32   reserved_2      :  4;
-                        __u32   dest_id         : 24;   /* Destination ID */
-#elif defined(__BIG_ENDIAN_BITFIELD)
-                        __u32   dest_id         : 24;   /* Destination ID */
-                        __u32   reserved_2      :  4;
-                        __u32   redirection_hint:  1;   /*0: dedicated CPU
-                                                          1: lowest priority */
-                        __u32   dest_mode       :  1;   /*0:physic | 1:logic */
-                        __u32   reserved_1      :  2;
-#else
-#error "Bitfield endianness not defined! Check your byteorder.h"
-#endif
-                }u;
-                __u32  value;
-        }lo_address;
-        __u32   hi_address;
-} __attribute__ ((packed));
-
 struct msi_desc {
         struct {
                 __u8    type    : 5;    /* {0: unused, 5h:MSI, 11h:MSI-X} */
@@ -132,7 +133,7 @@ struct msi_desc {
                 __u8    reserved: 1;    /* reserved                       */
                 __u8    entry_nr;       /* specific enabled entry         */
                 __u8    default_vector; /* default pre-assigned vector    */
-                __u8    current_cpu;    /* current destination cpu        */
+                __u8    unused;         /* formerly unused destination cpu*/
         }msi_attrib;
 
         struct {
@@ -142,6 +143,14 @@ struct msi_desc {
 
         void __iomem *mask_base;
         struct pci_dev *dev;
+
+#ifdef CONFIG_PM
+        /* PM save area for MSIX address/data */
+
+        u32     address_hi_save;
+        u32     address_lo_save;
+        u32     data_save;
+#endif
 };
 
 #endif /* MSI_H */
diff --git a/drivers/pci/pci-acpi.c b/drivers/pci/pci-acpi.c
index c2ecae5ff0c1..bb7456c1dbac 100644
--- a/drivers/pci/pci-acpi.c
+++ b/drivers/pci/pci-acpi.c
@@ -267,7 +267,7 @@ static int acpi_pci_set_power_state(struct pci_dev *dev, pci_power_t state)
 
 
 /* ACPI bus type */
-static int pci_acpi_find_device(struct device *dev, acpi_handle *handle)
+static int acpi_pci_find_device(struct device *dev, acpi_handle *handle)
 {
         struct pci_dev * pci_dev;
         acpi_integer    addr;
@@ -281,7 +281,7 @@ static int pci_acpi_find_device(struct device *dev, acpi_handle *handle)
         return 0;
 }
 
-static int pci_acpi_find_root_bridge(struct device *dev, acpi_handle *handle)
+static int acpi_pci_find_root_bridge(struct device *dev, acpi_handle *handle)
 {
         int num;
         unsigned int seg, bus;
@@ -299,21 +299,21 @@ static int pci_acpi_find_root_bridge(struct device *dev, acpi_handle *handle)
         return 0;
 }
 
-static struct acpi_bus_type pci_acpi_bus = {
+static struct acpi_bus_type acpi_pci_bus = {
         .bus = &pci_bus_type,
-        .find_device = pci_acpi_find_device,
-        .find_bridge = pci_acpi_find_root_bridge,
+        .find_device = acpi_pci_find_device,
+        .find_bridge = acpi_pci_find_root_bridge,
 };
 
-static int __init pci_acpi_init(void)
+static int __init acpi_pci_init(void)
 {
         int ret;
 
-        ret = register_acpi_bus_type(&pci_acpi_bus);
+        ret = register_acpi_bus_type(&acpi_pci_bus);
         if (ret)
                 return 0;
         platform_pci_choose_state = acpi_pci_choose_state;
         platform_pci_set_power_state = acpi_pci_set_power_state;
         return 0;
 }
-arch_initcall(pci_acpi_init);
+arch_initcall(acpi_pci_init);
diff --git a/drivers/pci/pci-sysfs.c b/drivers/pci/pci-sysfs.c
index 56ac2bc003c7..bc405c035ce3 100644
--- a/drivers/pci/pci-sysfs.c
+++ b/drivers/pci/pci-sysfs.c
@@ -43,6 +43,29 @@ pci_config_attr(subsystem_vendor, "0x%04x\n");
 pci_config_attr(subsystem_device, "0x%04x\n");
 pci_config_attr(class, "0x%06x\n");
 pci_config_attr(irq, "%u\n");
+pci_config_attr(is_enabled, "%u\n");
+
+static ssize_t broken_parity_status_show(struct device *dev,
+                                         struct device_attribute *attr,
+                                         char *buf)
+{
+        struct pci_dev *pdev = to_pci_dev(dev);
+        return sprintf (buf, "%u\n", pdev->broken_parity_status);
+}
+
+static ssize_t broken_parity_status_store(struct device *dev,
+                                          struct device_attribute *attr,
+                                          const char *buf, size_t count)
+{
+        struct pci_dev *pdev = to_pci_dev(dev);
+        ssize_t consumed = -EINVAL;
+
+        if ((count > 0) && (*buf == '0' || *buf == '1')) {
+                pdev->broken_parity_status = *buf == '1' ? 1 : 0;
+                consumed = count;
+        }
+        return consumed;
+}
 
 static ssize_t local_cpus_show(struct device *dev,
                         struct device_attribute *attr, char *buf)
@@ -90,6 +113,25 @@ static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
                        (u8)(pci_dev->class >> 16), (u8)(pci_dev->class >> 8),
                        (u8)(pci_dev->class));
 }
+static ssize_t
+is_enabled_store(struct device *dev, struct device_attribute *attr,
+                const char *buf, size_t count)
+{
+        struct pci_dev *pdev = to_pci_dev(dev);
+
+        /* this can crash the machine when done on the "wrong" device */
+        if (!capable(CAP_SYS_ADMIN))
+                return count;
+
+        if (*buf == '0')
+                pci_disable_device(pdev);
+
+        if (*buf == '1')
+                pci_enable_device(pdev);
+
+        return count;
+}
+
 
 struct device_attribute pci_dev_attrs[] = {
         __ATTR_RO(resource),
@@ -101,6 +143,9 @@ struct device_attribute pci_dev_attrs[] = {
         __ATTR_RO(irq),
         __ATTR_RO(local_cpus),
         __ATTR_RO(modalias),
+        __ATTR(enable, 0600, is_enabled_show, is_enabled_store),
+        __ATTR(broken_parity_status,(S_IRUGO|S_IWUSR),
+                broken_parity_status_show,broken_parity_status_store),
         __ATTR_NULL,
 };
 
diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c
index fde41cc14734..d408a3c30426 100644
--- a/drivers/pci/pci.c
+++ b/drivers/pci/pci.c
@@ -517,7 +517,12 @@ pci_enable_device_bars(struct pci_dev *dev, int bars)
 int
 pci_enable_device(struct pci_dev *dev)
 {
-        int err = pci_enable_device_bars(dev, (1 << PCI_NUM_RESOURCES) - 1);
+        int err;
+
+        if (dev->is_enabled)
+                return 0;
+
+        err = pci_enable_device_bars(dev, (1 << PCI_NUM_RESOURCES) - 1);
         if (err)
                 return err;
         pci_fixup_device(pci_fixup_enable, dev);
@@ -546,7 +551,14 @@ void
 pci_disable_device(struct pci_dev *dev)
 {
         u16 pci_command;
-        
+
+        if (dev->msi_enabled)
+                disable_msi_mode(dev, pci_find_capability(dev, PCI_CAP_ID_MSI),
+                        PCI_CAP_ID_MSI);
+        if (dev->msix_enabled)
+                disable_msi_mode(dev, pci_find_capability(dev, PCI_CAP_ID_MSI),
+                        PCI_CAP_ID_MSIX);
+
         pci_read_config_word(dev, PCI_COMMAND, &pci_command);
         if (pci_command & PCI_COMMAND_MASTER) {
                 pci_command &= ~PCI_COMMAND_MASTER;
diff --git a/drivers/pci/pci.h b/drivers/pci/pci.h
index 30630cbe2fe3..29bdeca031a8 100644
--- a/drivers/pci/pci.h
+++ b/drivers/pci/pci.h
@@ -40,7 +40,7 @@ extern int pci_bus_find_capability (struct pci_bus *bus, unsigned int devfn, int
 extern void pci_remove_legacy_files(struct pci_bus *bus);
 
 /* Lock for read/write access to pci device and bus lists */
-extern spinlock_t pci_bus_lock;
+extern struct rw_semaphore pci_bus_sem;
 
 #ifdef CONFIG_X86_IO_APIC
 extern int pci_msi_quirk;
diff --git a/drivers/pci/probe.c b/drivers/pci/probe.c
index a10ed9dab2c2..f89dbc3738b7 100644
--- a/drivers/pci/probe.c
+++ b/drivers/pci/probe.c
@@ -180,25 +180,31 @@ static void pci_read_bases(struct pci_dev *dev, unsigned int howmany, int rom)
                 res->flags |= pci_calc_resource_flags(l);
                 if ((l & (PCI_BASE_ADDRESS_SPACE | PCI_BASE_ADDRESS_MEM_TYPE_MASK))
                     == (PCI_BASE_ADDRESS_SPACE_MEMORY | PCI_BASE_ADDRESS_MEM_TYPE_64)) {
-                        pci_read_config_dword(dev, reg+4, &l);
+                        u32 szhi, lhi;
+                        pci_read_config_dword(dev, reg+4, &lhi);
+                        pci_write_config_dword(dev, reg+4, ~0);
+                        pci_read_config_dword(dev, reg+4, &szhi);
+                        pci_write_config_dword(dev, reg+4, lhi);
+                        szhi = pci_size(lhi, szhi, 0xffffffff);
                         next++;
 #if BITS_PER_LONG == 64
-                        res->start |= ((unsigned long) l) << 32;
+                        res->start |= ((unsigned long) lhi) << 32;
                         res->end = res->start + sz;
-                        pci_write_config_dword(dev, reg+4, ~0);
-                        pci_read_config_dword(dev, reg+4, &sz);
-                        pci_write_config_dword(dev, reg+4, l);
-                        sz = pci_size(l, sz, 0xffffffff);
-                        if (sz) {
+                        if (szhi) {
                                 /* This BAR needs > 4GB?  Wow. */
-                                res->end |= (unsigned long)sz<<32;
+                                res->end |= (unsigned long)szhi<<32;
                         }
 #else
-                        if (l) {
-                                printk(KERN_ERR "PCI: Unable to handle 64-bit address for device %s\n", pci_name(dev));
+                        if (szhi) {
+                                printk(KERN_ERR "PCI: Unable to handle 64-bit BAR for device %s\n", pci_name(dev));
                                 res->start = 0;
                                 res->flags = 0;
-                                continue;
+                        } else if (lhi) {
+                                /* 64-bit wide address, treat as disabled */
+                                pci_write_config_dword(dev, reg, l & ~(u32)PCI_BASE_ADDRESS_MEM_MASK);
+                                pci_write_config_dword(dev, reg+4, 0);
+                                res->start = 0;
+                                res->end = sz;
                         }
 #endif
                 }
@@ -377,9 +383,9 @@ struct pci_bus * __devinit pci_add_new_bus(struct pci_bus *parent, struct pci_de
 
         child = pci_alloc_child_bus(parent, dev, busnr);
         if (child) {
-                spin_lock(&pci_bus_lock);
+                down_write(&pci_bus_sem);
                 list_add_tail(&child->node, &parent->children);
-                spin_unlock(&pci_bus_lock);
+                up_write(&pci_bus_sem);
         }
         return child;
 }
@@ -838,9 +844,9 @@ void __devinit pci_device_add(struct pci_dev *dev, struct pci_bus *bus)
          * and the bus list for fixup functions, etc.
          */
         INIT_LIST_HEAD(&dev->global_list);
-        spin_lock(&pci_bus_lock);
+        down_write(&pci_bus_sem);
         list_add_tail(&dev->bus_list, &bus->devices);
-        spin_unlock(&pci_bus_lock);
+        up_write(&pci_bus_sem);
 }
 
 struct pci_dev * __devinit
@@ -975,9 +981,10 @@ struct pci_bus * __devinit pci_create_bus(struct device *parent,
                 pr_debug("PCI: Bus %04x:%02x already known\n", pci_domain_nr(b), bus);
                 goto err_out;
         }
-        spin_lock(&pci_bus_lock);
+
+        down_write(&pci_bus_sem);
         list_add_tail(&b->node, &pci_root_buses);
-        spin_unlock(&pci_bus_lock);
+        up_write(&pci_bus_sem);
 
         memset(dev, 0, sizeof(*dev));
         dev->parent = parent;
@@ -1017,9 +1024,9 @@ class_dev_create_file_err:
 class_dev_reg_err:
         device_unregister(dev);
 dev_reg_err:
-        spin_lock(&pci_bus_lock);
+        down_write(&pci_bus_sem);
         list_del(&b->node);
-        spin_unlock(&pci_bus_lock);
+        up_write(&pci_bus_sem);
 err_out:
         kfree(dev);
         kfree(b);
diff --git a/drivers/pci/quirks.c b/drivers/pci/quirks.c
index d378478612fb..4364d793f73b 100644
--- a/drivers/pci/quirks.c
+++ b/drivers/pci/quirks.c
@@ -24,6 +24,17 @@
 #include <linux/acpi.h>
 #include "pci.h"
 
+/* The Mellanox Tavor device gives false positive parity errors
+ * Mark this device with a broken_parity_status, to allow
+ * PCI scanning code to "skip" this now blacklisted device.
+ */
+static void __devinit quirk_mellanox_tavor(struct pci_dev *dev)
+{
+        dev->broken_parity_status = 1;  /* This device gives false positives */
+}
+DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_MELLANOX,PCI_DEVICE_ID_MELLANOX_TAVOR,quirk_mellanox_tavor);
+DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_MELLANOX,PCI_DEVICE_ID_MELLANOX_TAVOR_BRIDGE,quirk_mellanox_tavor);
+
 /* Deal with broken BIOS'es that neglect to enable passive release,
    which can cause problems in combination with the 82441FX/PPro MTRRs */
 static void __devinit quirk_passive_release(struct pci_dev *dev)
@@ -878,27 +889,30 @@ DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL,	PCI_DEVICE_ID_INTEL_82375,	quirk_e
  * when a PCI-Soundcard is added. The BIOS only gives Options
  * "Disabled" and "AUTO". This Quirk Sets the corresponding
  * Register-Value to enable the Soundcard.
+ *
+ * FIXME: Presently this quirk will run on anything that has an 8237
+ * which isn't correct, we need to check DMI tables or something in
+ * order to make sure it only runs on the MSI-K8T-Neo2Fir.  Because it
+ * runs everywhere at present we suppress the printk output in most
+ * irrelevant cases.
  */
 static void __init k8t_sound_hostbridge(struct pci_dev *dev)
 {
         unsigned char val;
 
-        printk(KERN_INFO "PCI: Quirk-MSI-K8T Soundcard On\n");
         pci_read_config_byte(dev, 0x50, &val);
         if (val == 0x88 || val == 0xc8) {
+                /* Assume it's probably a MSI-K8T-Neo2Fir */
+                printk(KERN_INFO "PCI: MSI-K8T-Neo2Fir, attempting to turn soundcard ON\n");
                 pci_write_config_byte(dev, 0x50, val & (~0x40));
 
                 /* Verify the Change for Status output */
                 pci_read_config_byte(dev, 0x50, &val);
                 if (val & 0x40)
-                        printk(KERN_INFO "PCI: MSI-K8T soundcard still off\n");
+                        printk(KERN_INFO "PCI: MSI-K8T-Neo2Fir, soundcard still off\n");
                 else
-                        printk(KERN_INFO "PCI: MSI-K8T soundcard on\n");
-        } else {
-                printk(KERN_INFO "PCI: Unexpected Value in PCI-Register: "
-                                        "no Change!\n");
+                        printk(KERN_INFO "PCI: MSI-K8T-Neo2Fir, soundcard on\n");
         }
-
 }
 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8237, k8t_sound_hostbridge);
 
@@ -1485,6 +1499,25 @@ static void __devinit quirk_p64h2_1k_io(struct pci_dev *dev)
 }
 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL,   0x1460,         quirk_p64h2_1k_io);
 
+/* Under some circumstances, AER is not linked with extended capabilities.
+ * Force it to be linked by setting the corresponding control bit in the
+ * config space.
+ */
+static void __devinit quirk_nvidia_ck804_pcie_aer_ext_cap(struct pci_dev *dev)
+{
+        uint8_t b;
+        if (pci_read_config_byte(dev, 0xf41, &b) == 0) {
+                if (!(b & 0x20)) {
+                        pci_write_config_byte(dev, 0xf41, b | 0x20);
+                        printk(KERN_INFO
+                               "PCI: Linking AER extended capability on %s\n",
+                               pci_name(dev));
+                }
+        }
+}
+DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_NVIDIA,  PCI_DEVICE_ID_NVIDIA_CK804_PCIE,
+                        quirk_nvidia_ck804_pcie_aer_ext_cap);
+
 EXPORT_SYMBOL(pcie_mch_quirk);
 #ifdef CONFIG_HOTPLUG
 EXPORT_SYMBOL(pci_fixup_device);
diff --git a/drivers/pci/remove.c b/drivers/pci/remove.c
index 1a6bf9de166f..99ffbd478b29 100644
--- a/drivers/pci/remove.c
+++ b/drivers/pci/remove.c
@@ -22,18 +22,18 @@ static void pci_destroy_dev(struct pci_dev *dev)
                 pci_proc_detach_device(dev);
                 pci_remove_sysfs_dev_files(dev);
                 device_unregister(&dev->dev);
-                spin_lock(&pci_bus_lock);
+                down_write(&pci_bus_sem);
                 list_del(&dev->global_list);
                 dev->global_list.next = dev->global_list.prev = NULL;
-                spin_unlock(&pci_bus_lock);
+                up_write(&pci_bus_sem);
         }
 
         /* Remove the device from the device lists, and prevent any further
          * list accesses from this device */
-        spin_lock(&pci_bus_lock);
+        down_write(&pci_bus_sem);
         list_del(&dev->bus_list);
         dev->bus_list.next = dev->bus_list.prev = NULL;
-        spin_unlock(&pci_bus_lock);
+        up_write(&pci_bus_sem);
 
         pci_free_resources(dev);
         pci_dev_put(dev);
@@ -62,9 +62,9 @@ void pci_remove_bus(struct pci_bus *pci_bus)
 {
         pci_proc_detach_bus(pci_bus);
 
-        spin_lock(&pci_bus_lock);
+        down_write(&pci_bus_sem);
         list_del(&pci_bus->node);
-        spin_unlock(&pci_bus_lock);
+        up_write(&pci_bus_sem);
         pci_remove_legacy_files(pci_bus);
         class_device_remove_file(&pci_bus->class_dev,
                 &class_device_attr_cpuaffinity);
diff --git a/drivers/pci/search.c b/drivers/pci/search.c
index ce7dd6e7be60..622b3f8ba820 100644
--- a/drivers/pci/search.c
+++ b/drivers/pci/search.c
@@ -13,7 +13,7 @@
 #include <linux/interrupt.h>
 #include "pci.h"
 
-DEFINE_SPINLOCK(pci_bus_lock);
+DECLARE_RWSEM(pci_bus_sem);
 
 static struct pci_bus * __devinit
 pci_do_find_bus(struct pci_bus* bus, unsigned char busnr)
@@ -72,11 +72,11 @@ pci_find_next_bus(const struct pci_bus *from)
         struct pci_bus *b = NULL;
 
         WARN_ON(in_interrupt());
-        spin_lock(&pci_bus_lock);
+        down_read(&pci_bus_sem);
         n = from ? from->node.next : pci_root_buses.next;
         if (n != &pci_root_buses)
                 b = pci_bus_b(n);
-        spin_unlock(&pci_bus_lock);
+        up_read(&pci_bus_sem);
         return b;
 }
 
@@ -124,7 +124,7 @@ struct pci_dev * pci_get_slot(struct pci_bus *bus, unsigned int devfn)
         struct pci_dev *dev;
 
         WARN_ON(in_interrupt());
-        spin_lock(&pci_bus_lock);
+        down_read(&pci_bus_sem);
 
         list_for_each(tmp, &bus->devices) {
                 dev = pci_dev_b(tmp);
@@ -135,7 +135,7 @@ struct pci_dev * pci_get_slot(struct pci_bus *bus, unsigned int devfn)
         dev = NULL;
  out:
         pci_dev_get(dev);
-        spin_unlock(&pci_bus_lock);
+        up_read(&pci_bus_sem);
         return dev;
 }
 
@@ -167,7 +167,7 @@ static struct pci_dev * pci_find_subsys(unsigned int vendor,
         struct pci_dev *dev;
 
         WARN_ON(in_interrupt());
-        spin_lock(&pci_bus_lock);
+        down_read(&pci_bus_sem);
         n = from ? from->global_list.next : pci_devices.next;
 
         while (n && (n != &pci_devices)) {
@@ -181,7 +181,7 @@ static struct pci_dev * pci_find_subsys(unsigned int vendor,
         }
         dev = NULL;
 exit:
-        spin_unlock(&pci_bus_lock);
+        up_read(&pci_bus_sem);
         return dev;
 }
 
@@ -232,7 +232,7 @@ pci_get_subsys(unsigned int vendor, unsigned int device,
         struct pci_dev *dev;
 
         WARN_ON(in_interrupt());
-        spin_lock(&pci_bus_lock);
+        down_read(&pci_bus_sem);
         n = from ? from->global_list.next : pci_devices.next;
 
         while (n && (n != &pci_devices)) {
@@ -247,7 +247,7 @@ pci_get_subsys(unsigned int vendor, unsigned int device,
         dev = NULL;
 exit:
         dev = pci_dev_get(dev);
-        spin_unlock(&pci_bus_lock);
+        up_read(&pci_bus_sem);
         pci_dev_put(from);
         return dev;
 }
@@ -292,7 +292,7 @@ pci_find_device_reverse(unsigned int vendor, unsigned int device, const struct p
         struct pci_dev *dev;
 
         WARN_ON(in_interrupt());
-        spin_lock(&pci_bus_lock);
+        down_read(&pci_bus_sem);
         n = from ? from->global_list.prev : pci_devices.prev;
 
         while (n && (n != &pci_devices)) {
@@ -304,7 +304,7 @@ pci_find_device_reverse(unsigned int vendor, unsigned int device, const struct p
         }
         dev = NULL;
 exit:
-        spin_unlock(&pci_bus_lock);
+        up_read(&pci_bus_sem);
         return dev;
 }
 
@@ -328,7 +328,7 @@ struct pci_dev *pci_get_class(unsigned int class, struct pci_dev *from)
         struct pci_dev *dev;
 
         WARN_ON(in_interrupt());
-        spin_lock(&pci_bus_lock);
+        down_read(&pci_bus_sem);
         n = from ? from->global_list.next : pci_devices.next;
 
         while (n && (n != &pci_devices)) {
@@ -340,7 +340,7 @@ struct pci_dev *pci_get_class(unsigned int class, struct pci_dev *from)
         dev = NULL;
 exit:
         dev = pci_dev_get(dev);
-        spin_unlock(&pci_bus_lock);
+        up_read(&pci_bus_sem);
         pci_dev_put(from);
         return dev;
 }
@@ -362,7 +362,7 @@ int pci_dev_present(const struct pci_device_id *ids)
         int found = 0;
 
         WARN_ON(in_interrupt());
-        spin_lock(&pci_bus_lock);
+        down_read(&pci_bus_sem);
         while (ids->vendor || ids->subvendor || ids->class_mask) {
                 list_for_each_entry(dev, &pci_devices, global_list) {
                         if (pci_match_one_device(ids, dev)) {
@@ -372,8 +372,8 @@ int pci_dev_present(const struct pci_device_id *ids)
                 }
                 ids++;
         }
-exit:                           
-        spin_unlock(&pci_bus_lock);
+exit:
+        up_read(&pci_bus_sem);
         return found;
 }
 EXPORT_SYMBOL(pci_dev_present);
diff --git a/drivers/pci/setup-bus.c b/drivers/pci/setup-bus.c
index 28ce3a7ee434..35086e80faa9 100644
--- a/drivers/pci/setup-bus.c
+++ b/drivers/pci/setup-bus.c
@@ -55,9 +55,10 @@ pbus_assign_resources_sorted(struct pci_bus *bus)
         list_for_each_entry(dev, &bus->devices, bus_list) {
                 u16 class = dev->class >> 8;
 
-                /* Don't touch classless devices and host bridges.  */
+                /* Don't touch classless devices or host bridges or ioapics.  */
                 if (class == PCI_CLASS_NOT_DEFINED ||
-                    class == PCI_CLASS_BRIDGE_HOST)
+                    class == PCI_CLASS_BRIDGE_HOST ||
+                    class == PCI_CLASS_SYSTEM_PIC)
                         continue;
 
                 pdev_sort_resources(dev, &head);
diff --git a/drivers/pci/setup-res.c b/drivers/pci/setup-res.c
index ea9277b7f899..577f4b55c46d 100644
--- a/drivers/pci/setup-res.c
+++ b/drivers/pci/setup-res.c
@@ -155,6 +155,46 @@ int pci_assign_resource(struct pci_dev *dev, int resno)
         return ret;
 }
 
+#ifdef CONFIG_EMBEDDED
+int pci_assign_resource_fixed(struct pci_dev *dev, int resno)
+{
+        struct pci_bus *bus = dev->bus;
+        struct resource *res = dev->resource + resno;
+        unsigned int type_mask;
+        int i, ret = -EBUSY;
+
+        type_mask = IORESOURCE_IO | IORESOURCE_MEM | IORESOURCE_PREFETCH;
+
+        for (i = 0; i < PCI_BUS_NUM_RESOURCES; i++) {
+                struct resource *r = bus->resource[i];
+                if (!r)
+                        continue;
+
+                /* type_mask must match */
+                if ((res->flags ^ r->flags) & type_mask)
+                        continue;
+
+                ret = request_resource(r, res);
+
+                if (ret == 0)
+                        break;
+        }
+
+        if (ret) {
+                printk(KERN_ERR "PCI: Failed to allocate %s resource "
+                                "#%d:%llx@%llx for %s\n",
+                        res->flags & IORESOURCE_IO ? "I/O" : "mem",
+                        resno, (unsigned long long)(res->end - res->start + 1),
+                        (unsigned long long)res->start, pci_name(dev));
+        } else if (resno < PCI_BRIDGE_RESOURCES) {
+                pci_update_resource(dev, res, resno);
+        }
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(pci_assign_resource_fixed);
+#endif
+
 /* Sort resources by alignment */
 void __devinit
 pdev_sort_resources(struct pci_dev *dev, struct resource_list *head)
diff --git a/drivers/scsi/qla1280.c b/drivers/scsi/qla1280.c
index 77bb2351500c..680f6063954b 100644
--- a/drivers/scsi/qla1280.c
+++ b/drivers/scsi/qla1280.c
@@ -397,30 +397,6 @@
 #include "ql1280_fw.h"
 #include "ql1040_fw.h"
 
-
-/*
- * Missing PCI ID's
- */
-#ifndef PCI_DEVICE_ID_QLOGIC_ISP1080
-#define PCI_DEVICE_ID_QLOGIC_ISP1080    0x1080
-#endif
-#ifndef PCI_DEVICE_ID_QLOGIC_ISP1240
-#define PCI_DEVICE_ID_QLOGIC_ISP1240    0x1240
-#endif
-#ifndef PCI_DEVICE_ID_QLOGIC_ISP1280
-#define PCI_DEVICE_ID_QLOGIC_ISP1280    0x1280
-#endif
-#ifndef PCI_DEVICE_ID_QLOGIC_ISP10160
-#define PCI_DEVICE_ID_QLOGIC_ISP10160   0x1016
-#endif
-#ifndef PCI_DEVICE_ID_QLOGIC_ISP12160
-#define PCI_DEVICE_ID_QLOGIC_ISP12160   0x1216
-#endif
-
-#ifndef PCI_VENDOR_ID_AMI
-#define PCI_VENDOR_ID_AMI               0x101e
-#endif
-
 #ifndef BITS_PER_LONG
 #error "BITS_PER_LONG not defined!"
 #endif
diff --git a/drivers/scsi/sata_vsc.c b/drivers/scsi/sata_vsc.c
index 8a29ce340b47..27d658704cf9 100644
--- a/drivers/scsi/sata_vsc.c
+++ b/drivers/scsi/sata_vsc.c
@@ -433,13 +433,14 @@ err_out:
 
 
 /*
- * 0x1725/0x7174 is the Vitesse VSC-7174
- * 0x8086/0x3200 is the Intel 31244, which is supposed to be identical
- * compatibility is untested as of yet
+ * Intel 31244 is supposed to be identical.
+ * Compatibility is untested as of yet.
  */
 static const struct pci_device_id vsc_sata_pci_tbl[] = {
-        { 0x1725, 0x7174, PCI_ANY_ID, PCI_ANY_ID, 0x10600, 0xFFFFFF, 0 },
-        { 0x8086, 0x3200, PCI_ANY_ID, PCI_ANY_ID, 0x10600, 0xFFFFFF, 0 },
+        { PCI_VENDOR_ID_VITESSE, PCI_DEVICE_ID_VITESSE_VSC7174,
+          PCI_ANY_ID, PCI_ANY_ID, 0x10600, 0xFFFFFF, 0 },
+        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_GD31244,
+          PCI_ANY_ID, PCI_ANY_ID, 0x10600, 0xFFFFFF, 0 },
         { }
 };
 
diff --git a/drivers/video/console/mdacon.c b/drivers/video/console/mdacon.c
index 989e4d49e5bb..7f939d066a5a 100644
--- a/drivers/video/console/mdacon.c
+++ b/drivers/video/console/mdacon.c
@@ -313,8 +313,8 @@ static const char __init *mdacon_startup(void)
         mda_num_columns = 80;
         mda_num_lines   = 25;
 
-        mda_vram_base = VGA_MAP_MEM(0xb0000);
         mda_vram_len  = 0x01000;
+        mda_vram_base = VGA_MAP_MEM(0xb0000, mda_vram_len);
 
         mda_index_port  = 0x3b4;
         mda_value_port  = 0x3b5;
diff --git a/drivers/video/console/vgacon.c b/drivers/video/console/vgacon.c
index d5a04b68c4d4..e64d42e2449e 100644
--- a/drivers/video/console/vgacon.c
+++ b/drivers/video/console/vgacon.c
@@ -391,7 +391,7 @@ static const char __init *vgacon_startup(void)
                         static struct resource ega_console_resource =
                             { "ega", 0x3B0, 0x3BF };
                         vga_video_type = VIDEO_TYPE_EGAM;
-                        vga_vram_end = 0xb8000;
+                        vga_vram_size = 0x8000;
                         display_desc = "EGA+";
                         request_resource(&ioport_resource,
                                          &ega_console_resource);
@@ -401,7 +401,7 @@ static const char __init *vgacon_startup(void)
                         static struct resource mda2_console_resource =
                             { "mda", 0x3BF, 0x3BF };
                         vga_video_type = VIDEO_TYPE_MDA;
-                        vga_vram_end = 0xb2000;
+                        vga_vram_size = 0x2000;
                         display_desc = "*MDA";
                         request_resource(&ioport_resource,
                                          &mda1_console_resource);
@@ -418,7 +418,7 @@ static const char __init *vgacon_startup(void)
                 if ((ORIG_VIDEO_EGA_BX & 0xff) != 0x10) {
                         int i;
 
-                        vga_vram_end = 0xc0000;
+                        vga_vram_size = 0x8000;
 
                         if (!ORIG_VIDEO_ISVGA) {
                                 static struct resource ega_console_resource
@@ -443,7 +443,7 @@ static const char __init *vgacon_startup(void)
                                  * and COE=1 isn't necessarily a good idea)
                                  */
                                 vga_vram_base = 0xa0000;
-                                vga_vram_end = 0xb0000;
+                                vga_vram_size = 0x10000;
                                 outb_p(6, VGA_GFX_I);
                                 outb_p(6, VGA_GFX_D);
 #endif
@@ -475,7 +475,7 @@ static const char __init *vgacon_startup(void)
                         static struct resource cga_console_resource =
                             { "cga", 0x3D4, 0x3D5 };
                         vga_video_type = VIDEO_TYPE_CGA;
-                        vga_vram_end = 0xba000;
+                        vga_vram_size = 0x2000;
                         display_desc = "*CGA";
                         request_resource(&ioport_resource,
                                          &cga_console_resource);
@@ -483,9 +483,8 @@ static const char __init *vgacon_startup(void)
                 }
         }
 
-        vga_vram_base = VGA_MAP_MEM(vga_vram_base);
-        vga_vram_end = VGA_MAP_MEM(vga_vram_end);
-        vga_vram_size = vga_vram_end - vga_vram_base;
+        vga_vram_base = VGA_MAP_MEM(vga_vram_base, vga_vram_size);
+        vga_vram_end = vga_vram_base + vga_vram_size;
 
         /*
          *      Find out if there is a graphics card present.
@@ -1020,14 +1019,14 @@ static int vgacon_do_font_op(struct vgastate *state,char *arg,int set,int ch512)
         char *charmap;
         
         if (vga_video_type != VIDEO_TYPE_EGAM) {
-                charmap = (char *) VGA_MAP_MEM(colourmap);
+                charmap = (char *) VGA_MAP_MEM(colourmap, 0);
                 beg = 0x0e;
 #ifdef VGA_CAN_DO_64KB
                 if (vga_video_type == VIDEO_TYPE_VGAC)
                         beg = 0x06;
 #endif
         } else {
-                charmap = (char *) VGA_MAP_MEM(blackwmap);
+                charmap = (char *) VGA_MAP_MEM(blackwmap, 0);
                 beg = 0x0a;
         }
 
diff --git a/drivers/video/vga16fb.c b/drivers/video/vga16fb.c
index f3f16fd9f231..4fd2a272e03d 100644
--- a/drivers/video/vga16fb.c
+++ b/drivers/video/vga16fb.c
@@ -1351,7 +1351,7 @@ static int __init vga16fb_probe(struct device *device)
         }
 
         /* XXX share VGA_FB_PHYS and I/O region with vgacon and others */
-        info->screen_base = (void __iomem *)VGA_MAP_MEM(VGA_FB_PHYS);
+        info->screen_base = (void __iomem *)VGA_MAP_MEM(VGA_FB_PHYS, 0);
 
         if (!info->screen_base) {
                 printk(KERN_ERR "vga16fb: unable to map device\n");
diff --git a/drivers/w1/Kconfig b/drivers/w1/Kconfig
index 5e61ed59a41e..f2d9a08e89ae 100644
--- a/drivers/w1/Kconfig
+++ b/drivers/w1/Kconfig
@@ -3,7 +3,7 @@ menu "Dallas's 1-wire bus"
 config W1
         tristate "Dallas's 1-wire support"
         ---help---
-          Dallas's 1-wire bus is useful to connect slow 1-pin devices
+          Dallas' 1-wire bus is useful to connect slow 1-pin devices
           such as iButtons and thermal sensors.
 
           If you want W1 support, you should say Y here.
@@ -11,6 +11,18 @@ config W1
           This W1 support can also be built as a module.  If so, the module
           will be called wire.ko.
 
+config W1_CON
+        depends on CONNECTOR && W1
+        bool "Userspace communication over connector"
+        default y
+        --- help ---
+          This allows to communicate with userspace using connector [Documentation/connector].
+          There are three types of messages between w1 core and userspace:
+          1. Events. They are generated each time new master or slave device found
+                either due to automatic or requested search.
+          2. Userspace commands. Includes read/write and search/alarm search comamnds.
+          3. Replies to userspace commands.
+
 source drivers/w1/masters/Kconfig
 source drivers/w1/slaves/Kconfig
 
diff --git a/drivers/w1/Makefile b/drivers/w1/Makefile
index 0c2aa22d8c04..93845a2c7c21 100644
--- a/drivers/w1/Makefile
+++ b/drivers/w1/Makefile
@@ -2,10 +2,6 @@
 # Makefile for the Dallas's 1-wire bus.
 #
 
-ifneq ($(CONFIG_NET), y)
-EXTRA_CFLAGS    += -DNETLINK_DISABLED
-endif
-
 ifeq ($(CONFIG_W1_DS2433_CRC), y)
 EXTRA_CFLAGS    += -DCONFIG_W1_F23_CRC
 endif
diff --git a/drivers/w1/masters/Kconfig b/drivers/w1/masters/Kconfig
index c6bad4dbdc64..2fb425536eae 100644
--- a/drivers/w1/masters/Kconfig
+++ b/drivers/w1/masters/Kconfig
@@ -15,24 +15,15 @@ config W1_MASTER_MATROX
           This support is also available as a module.  If so, the module
           will be called matrox_w1.ko.
 
-config W1_MASTER_DS9490
-        tristate "DS9490R transport layer driver"
-        depends on W1 && USB
-        help
-          Say Y here if you want to have a driver for DS9490R UWB <-> W1 bridge.
-
-          This support is also available as a module.  If so, the module
-          will be called ds9490r.ko.
-
-config W1_MASTER_DS9490_BRIDGE
-        tristate "DS9490R USB <-> W1 transport layer for 1-wire"
-        depends on W1_MASTER_DS9490
-        help
-          Say Y here if you want to communicate with your 1-wire devices
-          using DS9490R USB bridge.
-
-          This support is also available as a module.  If so, the module
-          will be called ds_w1_bridge.ko.
+config W1_MASTER_DS2490
+        tristate "DS2490 USB <-> W1 transport layer for 1-wire"
+        depends on W1 && USB
+        help
+          Say Y here if you want to have a driver for DS2490 based USB <-> W1 bridges,
+          for example DS9490*.
+
+          This support is also available as a module.  If so, the module
+          will be called ds2490.ko.
 
 config W1_MASTER_DS2482
         tristate "Maxim DS2482 I2C to 1-Wire bridge"
diff --git a/drivers/w1/masters/Makefile b/drivers/w1/masters/Makefile
index 1f3c8b983dc1..4cee256a8134 100644
--- a/drivers/w1/masters/Makefile
+++ b/drivers/w1/masters/Makefile
@@ -3,11 +3,6 @@
 #
 
 obj-$(CONFIG_W1_MASTER_MATROX)          += matrox_w1.o
-
-obj-$(CONFIG_W1_MASTER_DS9490)          += ds9490r.o
-ds9490r-objs    := dscore.o
-
-obj-$(CONFIG_W1_MASTER_DS9490_BRIDGE)   += ds_w1_bridge.o
-
+obj-$(CONFIG_W1_MASTER_DS2490)          += ds2490.o
 obj-$(CONFIG_W1_MASTER_DS2482)          += ds2482.o
 
diff --git a/drivers/w1/masters/ds2482.c b/drivers/w1/masters/ds2482.c
index d1cacd23576b..af492cc48db2 100644
--- a/drivers/w1/masters/ds2482.c
+++ b/drivers/w1/masters/ds2482.c
@@ -125,7 +125,7 @@ struct ds2482_w1_chan {
 
 struct ds2482_data {
         struct i2c_client       client;
-        struct semaphore        access_lock;
+        struct mutex            access_lock;
 
         /* 1-wire interface(s) */
         int                     w1_count;       /* 1 or 8 */
@@ -265,7 +265,7 @@ static u8 ds2482_w1_touch_bit(void *data, u8 bit)
         struct ds2482_data    *pdev = pchan->pdev;
         int status = -1;
 
-        down(&pdev->access_lock);
+        mutex_lock(&pdev->access_lock);
 
         /* Select the channel */
         ds2482_wait_1wire_idle(pdev);
@@ -277,7 +277,7 @@ static u8 ds2482_w1_touch_bit(void *data, u8 bit)
                                   bit ? 0xFF : 0))
                 status = ds2482_wait_1wire_idle(pdev);
 
-        up(&pdev->access_lock);
+        mutex_unlock(&pdev->access_lock);
 
         return (status & DS2482_REG_STS_SBR) ? 1 : 0;
 }
@@ -297,7 +297,7 @@ static u8 ds2482_w1_triplet(void *data, u8 dbit)
         struct ds2482_data    *pdev = pchan->pdev;
         int status = (3 << 5);
 
-        down(&pdev->access_lock);
+        mutex_lock(&pdev->access_lock);
 
         /* Select the channel */
         ds2482_wait_1wire_idle(pdev);
@@ -309,7 +309,7 @@ static u8 ds2482_w1_triplet(void *data, u8 dbit)
                                   dbit ? 0xFF : 0))
                 status = ds2482_wait_1wire_idle(pdev);
 
-        up(&pdev->access_lock);
+        mutex_unlock(&pdev->access_lock);
 
         /* Decode the status */
         return (status >> 5);
@@ -326,7 +326,7 @@ static void ds2482_w1_write_byte(void *data, u8 byte)
         struct ds2482_w1_chan *pchan = data;
         struct ds2482_data    *pdev = pchan->pdev;
 
-        down(&pdev->access_lock);
+        mutex_lock(&pdev->access_lock);
 
         /* Select the channel */
         ds2482_wait_1wire_idle(pdev);
@@ -336,7 +336,7 @@ static void ds2482_w1_write_byte(void *data, u8 byte)
         /* Send the write byte command */
         ds2482_send_cmd_data(pdev, DS2482_CMD_1WIRE_WRITE_BYTE, byte);
 
-        up(&pdev->access_lock);
+        mutex_unlock(&pdev->access_lock);
 }
 
 /**
@@ -351,7 +351,7 @@ static u8 ds2482_w1_read_byte(void *data)
         struct ds2482_data    *pdev = pchan->pdev;
         int result;
 
-        down(&pdev->access_lock);
+        mutex_lock(&pdev->access_lock);
 
         /* Select the channel */
         ds2482_wait_1wire_idle(pdev);
@@ -370,7 +370,7 @@ static u8 ds2482_w1_read_byte(void *data)
         /* Read the data byte */
         result = i2c_smbus_read_byte(&pdev->client);
 
-        up(&pdev->access_lock);
+        mutex_unlock(&pdev->access_lock);
 
         return result;
 }
@@ -389,7 +389,7 @@ static u8 ds2482_w1_reset_bus(void *data)
         int err;
         u8 retval = 1;
 
-        down(&pdev->access_lock);
+        mutex_lock(&pdev->access_lock);
 
         /* Select the channel */
         ds2482_wait_1wire_idle(pdev);
@@ -409,7 +409,7 @@ static u8 ds2482_w1_reset_bus(void *data)
                                              0xF0);
         }
 
-        up(&pdev->access_lock);
+        mutex_unlock(&pdev->access_lock);
 
         return retval;
 }
@@ -482,7 +482,7 @@ static int ds2482_detect(struct i2c_adapter *adapter, int address, int kind)
         snprintf(new_client->name, sizeof(new_client->name), "ds2482-%d00",
                  data->w1_count);
 
-        init_MUTEX(&data->access_lock);
+        mutex_init(&data->access_lock);
 
         /* Tell the I2C layer a new client has arrived */
         if ((err = i2c_attach_client(new_client)))
diff --git a/drivers/w1/masters/dscore.c b/drivers/w1/masters/ds2490.c
index 2cf7776a7080..299e274d241a 100644
--- a/drivers/w1/masters/dscore.c
+++ b/drivers/w1/masters/ds2490.c
@@ -24,7 +24,136 @@
 #include <linux/mod_devicetable.h>
 #include <linux/usb.h>
 
-#include "dscore.h"
+#include "../w1_int.h"
+#include "../w1.h"
+
+/* COMMAND TYPE CODES */
+#define CONTROL_CMD                     0x00
+#define COMM_CMD                        0x01
+#define MODE_CMD                        0x02
+
+/* CONTROL COMMAND CODES */
+#define CTL_RESET_DEVICE                0x0000
+#define CTL_START_EXE                   0x0001
+#define CTL_RESUME_EXE                  0x0002
+#define CTL_HALT_EXE_IDLE               0x0003
+#define CTL_HALT_EXE_DONE               0x0004
+#define CTL_FLUSH_COMM_CMDS             0x0007
+#define CTL_FLUSH_RCV_BUFFER            0x0008
+#define CTL_FLUSH_XMT_BUFFER            0x0009
+#define CTL_GET_COMM_CMDS               0x000A
+
+/* MODE COMMAND CODES */
+#define MOD_PULSE_EN                    0x0000
+#define MOD_SPEED_CHANGE_EN             0x0001
+#define MOD_1WIRE_SPEED                 0x0002
+#define MOD_STRONG_PU_DURATION          0x0003
+#define MOD_PULLDOWN_SLEWRATE           0x0004
+#define MOD_PROG_PULSE_DURATION         0x0005
+#define MOD_WRITE1_LOWTIME              0x0006
+#define MOD_DSOW0_TREC                  0x0007
+
+/* COMMUNICATION COMMAND CODES */
+#define COMM_ERROR_ESCAPE               0x0601
+#define COMM_SET_DURATION               0x0012
+#define COMM_BIT_IO                     0x0020
+#define COMM_PULSE                      0x0030
+#define COMM_1_WIRE_RESET               0x0042
+#define COMM_BYTE_IO                    0x0052
+#define COMM_MATCH_ACCESS               0x0064
+#define COMM_BLOCK_IO                   0x0074
+#define COMM_READ_STRAIGHT              0x0080
+#define COMM_DO_RELEASE                 0x6092
+#define COMM_SET_PATH                   0x00A2
+#define COMM_WRITE_SRAM_PAGE            0x00B2
+#define COMM_WRITE_EPROM                0x00C4
+#define COMM_READ_CRC_PROT_PAGE         0x00D4
+#define COMM_READ_REDIRECT_PAGE_CRC     0x21E4
+#define COMM_SEARCH_ACCESS              0x00F4
+
+/* Communication command bits */
+#define COMM_TYPE                       0x0008
+#define COMM_SE                         0x0008
+#define COMM_D                          0x0008
+#define COMM_Z                          0x0008
+#define COMM_CH                         0x0008
+#define COMM_SM                         0x0008
+#define COMM_R                          0x0008
+#define COMM_IM                         0x0001
+
+#define COMM_PS                         0x4000
+#define COMM_PST                        0x4000
+#define COMM_CIB                        0x4000
+#define COMM_RTS                        0x4000
+#define COMM_DT                         0x2000
+#define COMM_SPU                        0x1000
+#define COMM_F                          0x0800
+#define COMM_NTP                        0x0400
+#define COMM_ICP                        0x0200
+#define COMM_RST                        0x0100
+
+#define PULSE_PROG                      0x01
+#define PULSE_SPUE                      0x02
+
+#define BRANCH_MAIN                     0xCC
+#define BRANCH_AUX                      0x33
+
+/*
+ * Duration of the strong pull-up pulse in milliseconds.
+ */
+#define PULLUP_PULSE_DURATION           750
+
+/* Status flags */
+#define ST_SPUA                         0x01  /* Strong Pull-up is active */
+#define ST_PRGA                         0x02  /* 12V programming pulse is being generated */
+#define ST_12VP                         0x04  /* external 12V programming voltage is present */
+#define ST_PMOD                         0x08  /* DS2490 powered from USB and external sources */
+#define ST_HALT                         0x10  /* DS2490 is currently halted */
+#define ST_IDLE                         0x20  /* DS2490 is currently idle */
+#define ST_EPOF                         0x80
+
+#define SPEED_NORMAL                    0x00
+#define SPEED_FLEXIBLE                  0x01
+#define SPEED_OVERDRIVE                 0x02
+
+#define NUM_EP                          4
+#define EP_CONTROL                      0
+#define EP_STATUS                       1
+#define EP_DATA_OUT                     2
+#define EP_DATA_IN                      3
+
+struct ds_device
+{
+        struct list_head        ds_entry;
+
+        struct usb_device       *udev;
+        struct usb_interface    *intf;
+
+        int                     ep[NUM_EP];
+
+        struct w1_bus_master    master;
+};
+
+struct ds_status
+{
+        u8                      enable;
+        u8                      speed;
+        u8                      pullup_dur;
+        u8                      ppuls_dur;
+        u8                      pulldown_slew;
+        u8                      write1_time;
+        u8                      write0_time;
+        u8                      reserved0;
+        u8                      status;
+        u8                      command0;
+        u8                      command1;
+        u8                      command_buffer_status;
+        u8                      data_out_buffer_status;
+        u8                      data_in_buffer_status;
+        u8                      reserved1;
+        u8                      reserved2;
+
+};
 
 static struct usb_device_id ds_id_table [] = {
         { USB_DEVICE(0x04fa, 0x2490) },
@@ -35,21 +164,12 @@ MODULE_DEVICE_TABLE(usb, ds_id_table);
 static int ds_probe(struct usb_interface *, const struct usb_device_id *);
 static void ds_disconnect(struct usb_interface *);
 
-int ds_touch_bit(struct ds_device *, u8, u8 *);
-int ds_read_byte(struct ds_device *, u8 *);
-int ds_read_bit(struct ds_device *, u8 *);
-int ds_write_byte(struct ds_device *, u8);
-int ds_write_bit(struct ds_device *, u8);
-static int ds_start_pulse(struct ds_device *, int);
-int ds_reset(struct ds_device *, struct ds_status *);
-struct ds_device * ds_get_device(void);
-void ds_put_device(struct ds_device *);
-
 static inline void ds_dump_status(unsigned char *, unsigned char *, int);
 static int ds_send_control(struct ds_device *, u16, u16);
-static int ds_send_control_mode(struct ds_device *, u16, u16);
 static int ds_send_control_cmd(struct ds_device *, u16, u16);
 
+static LIST_HEAD(ds_devices);
+static DEFINE_MUTEX(ds_mutex);
 
 static struct usb_driver ds_driver = {
         .name =         "DS9490R",
@@ -58,20 +178,6 @@ static struct usb_driver ds_driver = {
         .id_table =     ds_id_table,
 };
 
-static struct ds_device *ds_dev;
-
-struct ds_device * ds_get_device(void)
-{
-        if (ds_dev)
-                atomic_inc(&ds_dev->refcnt);
-        return ds_dev;
-}
-
-void ds_put_device(struct ds_device *dev)
-{
-        atomic_dec(&dev->refcnt);
-}
-
 static int ds_send_control_cmd(struct ds_device *dev, u16 value, u16 index)
 {
         int err;
@@ -86,7 +192,7 @@ static int ds_send_control_cmd(struct ds_device *dev, u16 value, u16 index)
 
         return err;
 }
-
+#if 0
 static int ds_send_control_mode(struct ds_device *dev, u16 value, u16 index)
 {
         int err;
@@ -101,7 +207,7 @@ static int ds_send_control_mode(struct ds_device *dev, u16 value, u16 index)
 
         return err;
 }
-
+#endif
 static int ds_send_control(struct ds_device *dev, u16 value, u16 index)
 {
         int err;
@@ -324,7 +430,7 @@ static int ds_wait_status(struct ds_device *dev, struct ds_status *st)
                 return 0;
 }
 
-int ds_reset(struct ds_device *dev, struct ds_status *st)
+static int ds_reset(struct ds_device *dev, struct ds_status *st)
 {
         int err;
 
@@ -345,7 +451,7 @@ int ds_reset(struct ds_device *dev, struct ds_status *st)
 }
 
 #if 0
-int ds_set_speed(struct ds_device *dev, int speed)
+static int ds_set_speed(struct ds_device *dev, int speed)
 {
         int err;
 
@@ -395,7 +501,7 @@ static int ds_start_pulse(struct ds_device *dev, int delay)
         return err;
 }
 
-int ds_touch_bit(struct ds_device *dev, u8 bit, u8 *tbit)
+static int ds_touch_bit(struct ds_device *dev, u8 bit, u8 *tbit)
 {
         int err, count;
         struct ds_status st;
@@ -427,7 +533,7 @@ int ds_touch_bit(struct ds_device *dev, u8 bit, u8 *tbit)
         return 0;
 }
 
-int ds_write_bit(struct ds_device *dev, u8 bit)
+static int ds_write_bit(struct ds_device *dev, u8 bit)
 {
         int err;
         struct ds_status st;
@@ -441,7 +547,7 @@ int ds_write_bit(struct ds_device *dev, u8 bit)
         return 0;
 }
 
-int ds_write_byte(struct ds_device *dev, u8 byte)
+static int ds_write_byte(struct ds_device *dev, u8 byte)
 {
         int err;
         struct ds_status st;
@@ -464,26 +570,7 @@ int ds_write_byte(struct ds_device *dev, u8 byte)
         return !(byte == rbyte);
 }
 
-int ds_read_bit(struct ds_device *dev, u8 *bit)
-{
-        int err;
-
-        err = ds_send_control_mode(dev, MOD_PULSE_EN, PULSE_SPUE);
-        if (err)
-                return err;
-
-        err = ds_send_control(dev, COMM_BIT_IO | COMM_IM | COMM_SPU | COMM_D, 0);
-        if (err)
-                return err;
-
-        err = ds_recv_data(dev, bit, sizeof(*bit));
-        if (err < 0)
-                return err;
-
-        return 0;
-}
-
-int ds_read_byte(struct ds_device *dev, u8 *byte)
+static int ds_read_byte(struct ds_device *dev, u8 *byte)
 {
         int err;
         struct ds_status st;
@@ -501,7 +588,7 @@ int ds_read_byte(struct ds_device *dev, u8 *byte)
         return 0;
 }
 
-int ds_read_block(struct ds_device *dev, u8 *buf, int len)
+static int ds_read_block(struct ds_device *dev, u8 *buf, int len)
 {
         struct ds_status st;
         int err;
@@ -527,7 +614,7 @@ int ds_read_block(struct ds_device *dev, u8 *buf, int len)
         return err;
 }
 
-int ds_write_block(struct ds_device *dev, u8 *buf, int len)
+static int ds_write_block(struct ds_device *dev, u8 *buf, int len)
 {
         int err;
         struct ds_status st;
@@ -555,7 +642,7 @@ int ds_write_block(struct ds_device *dev, u8 *buf, int len)
 
 #if 0
 
-int ds_search(struct ds_device *dev, u64 init, u64 *buf, u8 id_number, int conditional_search)
+static int ds_search(struct ds_device *dev, u64 init, u64 *buf, u8 id_number, int conditional_search)
 {
         int err;
         u16 value, index;
@@ -584,7 +671,7 @@ int ds_search(struct ds_device *dev, u64 init, u64 *buf, u8 id_number, int condi
         return err/8;
 }
 
-int ds_match_access(struct ds_device *dev, u64 init)
+static int ds_match_access(struct ds_device *dev, u64 init)
 {
         int err;
         struct ds_status st;
@@ -604,7 +691,7 @@ int ds_match_access(struct ds_device *dev, u64 init)
         return 0;
 }
 
-int ds_set_path(struct ds_device *dev, u64 init)
+static int ds_set_path(struct ds_device *dev, u64 init)
 {
         int err;
         struct ds_status st;
@@ -630,45 +717,156 @@ int ds_set_path(struct ds_device *dev, u64 init)
 
 #endif  /*  0  */
 
+static u8 ds9490r_touch_bit(void *data, u8 bit)
+{
+        u8 ret;
+        struct ds_device *dev = data;
+
+        if (ds_touch_bit(dev, bit, &ret))
+                return 0;
+
+        return ret;
+}
+
+static void ds9490r_write_bit(void *data, u8 bit)
+{
+        struct ds_device *dev = data;
+
+        ds_write_bit(dev, bit);
+}
+
+static void ds9490r_write_byte(void *data, u8 byte)
+{
+        struct ds_device *dev = data;
+
+        ds_write_byte(dev, byte);
+}
+
+static u8 ds9490r_read_bit(void *data)
+{
+        struct ds_device *dev = data;
+        int err;
+        u8 bit = 0;
+
+        err = ds_touch_bit(dev, 1, &bit);
+        if (err)
+                return 0;
+
+        return bit & 1;
+}
+
+static u8 ds9490r_read_byte(void *data)
+{
+        struct ds_device *dev = data;
+        int err;
+        u8 byte = 0;
+
+        err = ds_read_byte(dev, &byte);
+        if (err)
+                return 0;
+
+        return byte;
+}
+
+static void ds9490r_write_block(void *data, const u8 *buf, int len)
+{
+        struct ds_device *dev = data;
+
+        ds_write_block(dev, (u8 *)buf, len);
+}
+
+static u8 ds9490r_read_block(void *data, u8 *buf, int len)
+{
+        struct ds_device *dev = data;
+        int err;
+
+        err = ds_read_block(dev, buf, len);
+        if (err < 0)
+                return 0;
+
+        return len;
+}
+
+static u8 ds9490r_reset(void *data)
+{
+        struct ds_device *dev = data;
+        struct ds_status st;
+        int err;
+
+        memset(&st, 0, sizeof(st));
+
+        err = ds_reset(dev, &st);
+        if (err)
+                return 1;
+
+        return 0;
+}
+
+static int ds_w1_init(struct ds_device *dev)
+{
+        memset(&dev->master, 0, sizeof(struct w1_bus_master));
+
+        dev->master.data        = dev;
+        dev->master.touch_bit   = &ds9490r_touch_bit;
+        dev->master.read_bit    = &ds9490r_read_bit;
+        dev->master.write_bit   = &ds9490r_write_bit;
+        dev->master.read_byte   = &ds9490r_read_byte;
+        dev->master.write_byte  = &ds9490r_write_byte;
+        dev->master.read_block  = &ds9490r_read_block;
+        dev->master.write_block = &ds9490r_write_block;
+        dev->master.reset_bus   = &ds9490r_reset;
+
+        return w1_add_master_device(&dev->master);
+}
+
+static void ds_w1_fini(struct ds_device *dev)
+{
+        w1_remove_master_device(&dev->master);
+}
+
 static int ds_probe(struct usb_interface *intf,
                     const struct usb_device_id *udev_id)
 {
         struct usb_device *udev = interface_to_usbdev(intf);
         struct usb_endpoint_descriptor *endpoint;
         struct usb_host_interface *iface_desc;
+        struct ds_device *dev;
         int i, err;
 
-        ds_dev = kmalloc(sizeof(struct ds_device), GFP_KERNEL);
-        if (!ds_dev) {
+        dev = kmalloc(sizeof(struct ds_device), GFP_KERNEL);
+        if (!dev) {
                 printk(KERN_INFO "Failed to allocate new DS9490R structure.\n");
                 return -ENOMEM;
         }
+        dev->udev = usb_get_dev(udev);
+        if (!dev->udev) {
+                err = -ENOMEM;
+                goto err_out_free;
+        }
+        memset(dev->ep, 0, sizeof(dev->ep));
 
-        ds_dev->udev = usb_get_dev(udev);
-        usb_set_intfdata(intf, ds_dev);
+        usb_set_intfdata(intf, dev);
 
-        err = usb_set_interface(ds_dev->udev, intf->altsetting[0].desc.bInterfaceNumber, 3);
+        err = usb_set_interface(dev->udev, intf->altsetting[0].desc.bInterfaceNumber, 3);
         if (err) {
                 printk(KERN_ERR "Failed to set alternative setting 3 for %d interface: err=%d.\n",
                                 intf->altsetting[0].desc.bInterfaceNumber, err);
-                return err;
+                goto err_out_clear;
         }
 
-        err = usb_reset_configuration(ds_dev->udev);
+        err = usb_reset_configuration(dev->udev);
         if (err) {
                 printk(KERN_ERR "Failed to reset configuration: err=%d.\n", err);
-                return err;
+                goto err_out_clear;
         }
 
         iface_desc = &intf->altsetting[0];
         if (iface_desc->desc.bNumEndpoints != NUM_EP-1) {
                 printk(KERN_INFO "Num endpoints=%d. It is not DS9490R.\n", iface_desc->desc.bNumEndpoints);
-                return -ENODEV;
+                err = -EINVAL;
+                goto err_out_clear;
         }
 
-        atomic_set(&ds_dev->refcnt, 0);
-        memset(ds_dev->ep, 0, sizeof(ds_dev->ep));
-
         /*
          * This loop doesn'd show control 0 endpoint,
          * so we will fill only 1-3 endpoints entry.
@@ -676,54 +874,31 @@ static int ds_probe(struct usb_interface *intf,
         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
                 endpoint = &iface_desc->endpoint[i].desc;
 
-                ds_dev->ep[i+1] = endpoint->bEndpointAddress;
-
+                dev->ep[i+1] = endpoint->bEndpointAddress;
+#if 0
                 printk("%d: addr=%x, size=%d, dir=%s, type=%x\n",
                         i, endpoint->bEndpointAddress, le16_to_cpu(endpoint->wMaxPacketSize),
                         (endpoint->bEndpointAddress & USB_DIR_IN)?"IN":"OUT",
                         endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK);
+#endif
         }
 
-#if 0
-        {
-                int err, i;
-                u64 buf[3];
-                u64 init=0xb30000002078ee81ull;
-                struct ds_status st;
-
-                ds_reset(ds_dev, &st);
-                err = ds_search(ds_dev, init, buf, 3, 0);
-                if (err < 0)
-                        return err;
-                for (i=0; i<err; ++i)
-                        printk("%d: %llx\n", i, buf[i]);
-
-                printk("Resetting...\n");
-                ds_reset(ds_dev, &st);
-                printk("Setting path for %llx.\n", init);
-                err = ds_set_path(ds_dev, init);
-                if (err)
-                        return err;
-                printk("Calling MATCH_ACCESS.\n");
-                err = ds_match_access(ds_dev, init);
-                if (err)
-                        return err;
-
-                printk("Searching the bus...\n");
-                err = ds_search(ds_dev, init, buf, 3, 0);
-
-                printk("ds_search() returned %d\n", err);
-
-                if (err < 0)
-                        return err;
-                for (i=0; i<err; ++i)
-                        printk("%d: %llx\n", i, buf[i]);
+        err = ds_w1_init(dev);
+        if (err)
+                goto err_out_clear;
 
-                return 0;
-        }
-#endif
+        mutex_lock(&ds_mutex);
+        list_add_tail(&dev->ds_entry, &ds_devices);
+        mutex_unlock(&ds_mutex);
 
         return 0;
+
+err_out_clear:
+        usb_set_intfdata(intf, NULL);
+        usb_put_dev(dev->udev);
+err_out_free:
+        kfree(dev);
+        return err;
 }
 
 static void ds_disconnect(struct usb_interface *intf)
@@ -731,19 +906,19 @@ static void ds_disconnect(struct usb_interface *intf)
         struct ds_device *dev;
 
         dev = usb_get_intfdata(intf);
-        usb_set_intfdata(intf, NULL);
+        if (!dev)
+                return;
 
-        while (atomic_read(&dev->refcnt)) {
-                printk(KERN_INFO "Waiting for DS to become free: refcnt=%d.\n",
-                                atomic_read(&dev->refcnt));
+        mutex_lock(&ds_mutex);
+        list_del(&dev->ds_entry);
+        mutex_unlock(&ds_mutex);
 
-                if (msleep_interruptible(1000))
-                        flush_signals(current);
-        }
+        ds_w1_fini(dev);
+
+        usb_set_intfdata(intf, NULL);
 
         usb_put_dev(dev->udev);
         kfree(dev);
-        ds_dev = NULL;
 }
 
 static int ds_init(void)
@@ -769,27 +944,4 @@ module_exit(ds_fini);
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Evgeniy Polyakov <johnpol@2ka.mipt.ru>");
-
-EXPORT_SYMBOL(ds_touch_bit);
-EXPORT_SYMBOL(ds_read_byte);
-EXPORT_SYMBOL(ds_read_bit);
-EXPORT_SYMBOL(ds_read_block);
-EXPORT_SYMBOL(ds_write_byte);
-EXPORT_SYMBOL(ds_write_bit);
-EXPORT_SYMBOL(ds_write_block);
-EXPORT_SYMBOL(ds_reset);
-EXPORT_SYMBOL(ds_get_device);
-EXPORT_SYMBOL(ds_put_device);
-
-/*
- * This functions can be used for EEPROM programming,
- * when driver will be included into mainline this will
- * require uncommenting.
- */
-#if 0
-EXPORT_SYMBOL(ds_start_pulse);
-EXPORT_SYMBOL(ds_set_speed);
-EXPORT_SYMBOL(ds_detect);
-EXPORT_SYMBOL(ds_stop_pulse);
-EXPORT_SYMBOL(ds_search);
-#endif
+MODULE_DESCRIPTION("DS2490 USB <-> W1 bus master driver (DS9490*)");
diff --git a/drivers/w1/masters/ds_w1_bridge.c b/drivers/w1/masters/ds_w1_bridge.c
deleted file mode 100644
index 5d30783a3eb6..000000000000
--- a/drivers/w1/masters/ds_w1_bridge.c
+++ /dev/null
@@ -1,174 +0,0 @@
-/*
- *      ds_w1_bridge.c
- *
- * Copyright (c) 2004 Evgeniy Polyakov <johnpol@2ka.mipt.ru>
- *
- *
- * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- */
-
-#include <linux/module.h>
-#include <linux/types.h>
-
-#include "../w1.h"
-#include "../w1_int.h"
-#include "dscore.h"
-
-static struct ds_device *ds_dev;
-static struct w1_bus_master *ds_bus_master;
-
-static u8 ds9490r_touch_bit(void *data, u8 bit)
-{
-        u8 ret;
-        struct ds_device *dev = data;
-
-        if (ds_touch_bit(dev, bit, &ret))
-                return 0;
-
-        return ret;
-}
-
-static void ds9490r_write_bit(void *data, u8 bit)
-{
-        struct ds_device *dev = data;
-
-        ds_write_bit(dev, bit);
-}
-
-static void ds9490r_write_byte(void *data, u8 byte)
-{
-        struct ds_device *dev = data;
-
-        ds_write_byte(dev, byte);
-}
-
-static u8 ds9490r_read_bit(void *data)
-{
-        struct ds_device *dev = data;
-        int err;
-        u8 bit = 0;
-
-        err = ds_touch_bit(dev, 1, &bit);
-        if (err)
-                return 0;
-        //err = ds_read_bit(dev, &bit);
-        //if (err)
-        //      return 0;
-
-        return bit & 1;
-}
-
-static u8 ds9490r_read_byte(void *data)
-{
-        struct ds_device *dev = data;
-        int err;
-        u8 byte = 0;
-
-        err = ds_read_byte(dev, &byte);
-        if (err)
-                return 0;
-
-        return byte;
-}
-
-static void ds9490r_write_block(void *data, const u8 *buf, int len)
-{
-        struct ds_device *dev = data;
-
-        ds_write_block(dev, (u8 *)buf, len);
-}
-
-static u8 ds9490r_read_block(void *data, u8 *buf, int len)
-{
-        struct ds_device *dev = data;
-        int err;
-
-        err = ds_read_block(dev, buf, len);
-        if (err < 0)
-                return 0;
-
-        return len;
-}
-
-static u8 ds9490r_reset(void *data)
-{
-        struct ds_device *dev = data;
-        struct ds_status st;
-        int err;
-
-        memset(&st, 0, sizeof(st));
-
-        err = ds_reset(dev, &st);
-        if (err)
-                return 1;
-
-        return 0;
-}
-
-static int __devinit ds_w1_init(void)
-{
-        int err;
-
-        ds_bus_master = kmalloc(sizeof(*ds_bus_master), GFP_KERNEL);
-        if (!ds_bus_master) {
-                printk(KERN_ERR "Failed to allocate DS9490R USB<->W1 bus_master structure.\n");
-                return -ENOMEM;
-        }
-
-        ds_dev = ds_get_device();
-        if (!ds_dev) {
-                printk(KERN_ERR "DS9490R is not registered.\n");
-                err =  -ENODEV;
-                goto err_out_free_bus_master;
-        }
-
-        memset(ds_bus_master, 0, sizeof(*ds_bus_master));
-
-        ds_bus_master->data             = ds_dev;
-        ds_bus_master->touch_bit        = &ds9490r_touch_bit;
-        ds_bus_master->read_bit         = &ds9490r_read_bit;
-        ds_bus_master->write_bit        = &ds9490r_write_bit;
-        ds_bus_master->read_byte        = &ds9490r_read_byte;
-        ds_bus_master->write_byte       = &ds9490r_write_byte;
-        ds_bus_master->read_block       = &ds9490r_read_block;
-        ds_bus_master->write_block      = &ds9490r_write_block;
-        ds_bus_master->reset_bus        = &ds9490r_reset;
-
-        err = w1_add_master_device(ds_bus_master);
-        if (err)
-                goto err_out_put_device;
-
-        return 0;
-
-err_out_put_device:
-        ds_put_device(ds_dev);
-err_out_free_bus_master:
-        kfree(ds_bus_master);
-
-        return err;
-}
-
-static void __devexit ds_w1_fini(void)
-{
-        w1_remove_master_device(ds_bus_master);
-        ds_put_device(ds_dev);
-        kfree(ds_bus_master);
-}
-
-module_init(ds_w1_init);
-module_exit(ds_w1_fini);
-
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Evgeniy Polyakov <johnpol@2ka.mipt.ru>");
diff --git a/drivers/w1/masters/dscore.h b/drivers/w1/masters/dscore.h
deleted file mode 100644
index 6cf5671d6ebe..000000000000
--- a/drivers/w1/masters/dscore.h
+++ /dev/null
@@ -1,166 +0,0 @@
-/*
- *      dscore.h
- *
- * Copyright (c) 2004 Evgeniy Polyakov <johnpol@2ka.mipt.ru>
- *
- *
- * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- */
-
-#ifndef __DSCORE_H
-#define __DSCORE_H
-
-#include <linux/usb.h>
-#include <asm/atomic.h>
-
-/* COMMAND TYPE CODES */
-#define CONTROL_CMD                     0x00
-#define COMM_CMD                        0x01
-#define MODE_CMD                        0x02
-
-/* CONTROL COMMAND CODES */
-#define CTL_RESET_DEVICE                0x0000
-#define CTL_START_EXE                   0x0001
-#define CTL_RESUME_EXE                  0x0002
-#define CTL_HALT_EXE_IDLE               0x0003
-#define CTL_HALT_EXE_DONE               0x0004
-#define CTL_FLUSH_COMM_CMDS             0x0007
-#define CTL_FLUSH_RCV_BUFFER            0x0008
-#define CTL_FLUSH_XMT_BUFFER            0x0009
-#define CTL_GET_COMM_CMDS               0x000A
-
-/* MODE COMMAND CODES */
-#define MOD_PULSE_EN                    0x0000
-#define MOD_SPEED_CHANGE_EN             0x0001
-#define MOD_1WIRE_SPEED                 0x0002
-#define MOD_STRONG_PU_DURATION          0x0003
-#define MOD_PULLDOWN_SLEWRATE           0x0004
-#define MOD_PROG_PULSE_DURATION         0x0005
-#define MOD_WRITE1_LOWTIME              0x0006
-#define MOD_DSOW0_TREC                  0x0007
-
-/* COMMUNICATION COMMAND CODES */
-#define COMM_ERROR_ESCAPE               0x0601
-#define COMM_SET_DURATION               0x0012
-#define COMM_BIT_IO                     0x0020
-#define COMM_PULSE                      0x0030
-#define COMM_1_WIRE_RESET               0x0042
-#define COMM_BYTE_IO                    0x0052
-#define COMM_MATCH_ACCESS               0x0064
-#define COMM_BLOCK_IO                   0x0074
-#define COMM_READ_STRAIGHT              0x0080
-#define COMM_DO_RELEASE                 0x6092
-#define COMM_SET_PATH                   0x00A2
-#define COMM_WRITE_SRAM_PAGE            0x00B2
-#define COMM_WRITE_EPROM                0x00C4
-#define COMM_READ_CRC_PROT_PAGE         0x00D4
-#define COMM_READ_REDIRECT_PAGE_CRC     0x21E4
-#define COMM_SEARCH_ACCESS              0x00F4
-
-/* Communication command bits */
-#define COMM_TYPE                       0x0008
-#define COMM_SE                         0x0008
-#define COMM_D                          0x0008
-#define COMM_Z                          0x0008
-#define COMM_CH                         0x0008
-#define COMM_SM                         0x0008
-#define COMM_R                          0x0008
-#define COMM_IM                         0x0001
-
-#define COMM_PS                         0x4000
-#define COMM_PST                        0x4000
-#define COMM_CIB                        0x4000
-#define COMM_RTS                        0x4000
-#define COMM_DT                         0x2000
-#define COMM_SPU                        0x1000
-#define COMM_F                          0x0800
-#define COMM_NTP                        0x0400
-#define COMM_ICP                        0x0200
-#define COMM_RST                        0x0100
-
-#define PULSE_PROG                      0x01
-#define PULSE_SPUE                      0x02
-
-#define BRANCH_MAIN                     0xCC
-#define BRANCH_AUX                      0x33
-
-/*
- * Duration of the strong pull-up pulse in milliseconds.
- */
-#define PULLUP_PULSE_DURATION           750
-
-/* Status flags */
-#define ST_SPUA                         0x01  /* Strong Pull-up is active */
-#define ST_PRGA                         0x02  /* 12V programming pulse is being generated */
-#define ST_12VP                         0x04  /* external 12V programming voltage is present */
-#define ST_PMOD                         0x08  /* DS2490 powered from USB and external sources */
-#define ST_HALT                         0x10  /* DS2490 is currently halted */
-#define ST_IDLE                         0x20  /* DS2490 is currently idle */
-#define ST_EPOF                         0x80
-
-#define SPEED_NORMAL                    0x00
-#define SPEED_FLEXIBLE                  0x01
-#define SPEED_OVERDRIVE                 0x02
-
-#define NUM_EP                          4
-#define EP_CONTROL                      0
-#define EP_STATUS                       1
-#define EP_DATA_OUT                     2
-#define EP_DATA_IN                      3
-
-struct ds_device
-{
-        struct usb_device       *udev;
-        struct usb_interface    *intf;
-
-        int                     ep[NUM_EP];
-
-        atomic_t                refcnt;
-};
-
-struct ds_status
-{
-        u8                      enable;
-        u8                      speed;
-        u8                      pullup_dur;
-        u8                      ppuls_dur;
-        u8                      pulldown_slew;
-        u8                      write1_time;
-        u8                      write0_time;
-        u8                      reserved0;
-        u8                      status;
-        u8                      command0;
-        u8                      command1;
-        u8                      command_buffer_status;
-        u8                      data_out_buffer_status;
-        u8                      data_in_buffer_status;
-        u8                      reserved1;
-        u8                      reserved2;
-
-};
-
-int ds_touch_bit(struct ds_device *, u8, u8 *);
-int ds_read_byte(struct ds_device *, u8 *);
-int ds_read_bit(struct ds_device *, u8 *);
-int ds_write_byte(struct ds_device *, u8);
-int ds_write_bit(struct ds_device *, u8);
-int ds_reset(struct ds_device *, struct ds_status *);
-struct ds_device * ds_get_device(void);
-void ds_put_device(struct ds_device *);
-int ds_write_block(struct ds_device *, u8 *, int);
-int ds_read_block(struct ds_device *, u8 *, int);
-
-#endif /* __DSCORE_H */
-
diff --git a/drivers/w1/slaves/Kconfig b/drivers/w1/slaves/Kconfig
index f9d4c91fc533..d18d6424cd21 100644
--- a/drivers/w1/slaves/Kconfig
+++ b/drivers/w1/slaves/Kconfig
@@ -28,7 +28,7 @@ config W1_SLAVE_DS2433
 
 config W1_SLAVE_DS2433_CRC
         bool "Protect DS2433 data with a CRC16"
-        depends on W1_DS2433
+        depends on W1_SLAVE_DS2433
         select CRC16
         help
           Say Y here to protect DS2433 data with a CRC16.
diff --git a/drivers/w1/slaves/w1_ds2433.c b/drivers/w1/slaves/w1_ds2433.c
index fb118be789ea..2ac238f1480e 100644
--- a/drivers/w1/slaves/w1_ds2433.c
+++ b/drivers/w1/slaves/w1_ds2433.c
@@ -22,7 +22,6 @@
 #endif
 
 #include "../w1.h"
-#include "../w1_io.h"
 #include "../w1_int.h"
 #include "../w1_family.h"
 
@@ -106,11 +105,7 @@ static ssize_t w1_f23_read_bin(struct kobject *kobj, char *buf, loff_t off,
         if ((count = w1_f23_fix_count(off, count, W1_EEPROM_SIZE)) == 0)
                 return 0;
 
-        atomic_inc(&sl->refcnt);
-        if (down_interruptible(&sl->master->mutex)) {
-                count = 0;
-                goto out_dec;
-        }
+        mutex_lock(&sl->master->mutex);
 
 #ifdef CONFIG_W1_F23_CRC
 
@@ -141,9 +136,7 @@ static ssize_t w1_f23_read_bin(struct kobject *kobj, char *buf, loff_t off,
 #endif  /* CONFIG_W1_F23_CRC */
 
 out_up:
-        up(&sl->master->mutex);
-out_dec:
-        atomic_dec(&sl->refcnt);
+        mutex_unlock(&sl->master->mutex);
 
         return count;
 }
@@ -232,11 +225,7 @@ static ssize_t w1_f23_write_bin(struct kobject *kobj, char *buf, loff_t off,
         }
 #endif  /* CONFIG_W1_F23_CRC */
 
-        atomic_inc(&sl->refcnt);
-        if (down_interruptible(&sl->master->mutex)) {
-                count = 0;
-                goto out_dec;
-        }
+        mutex_lock(&sl->master->mutex);
 
         /* Can only write data to one page at a time */
         idx = 0;
@@ -254,9 +243,7 @@ static ssize_t w1_f23_write_bin(struct kobject *kobj, char *buf, loff_t off,
         }
 
 out_up:
-        up(&sl->master->mutex);
-out_dec:
-        atomic_dec(&sl->refcnt);
+        mutex_unlock(&sl->master->mutex);
 
         return count;
 }
diff --git a/drivers/w1/slaves/w1_smem.c b/drivers/w1/slaves/w1_smem.c
index c6d3be54f94c..cc8c02e92593 100644
--- a/drivers/w1/slaves/w1_smem.c
+++ b/drivers/w1/slaves/w1_smem.c
@@ -28,7 +28,6 @@
 #include <linux/types.h>
 
 #include "../w1.h"
-#include "../w1_io.h"
 #include "../w1_int.h"
 #include "../w1_family.h"
 
diff --git a/drivers/w1/slaves/w1_therm.c b/drivers/w1/slaves/w1_therm.c
index 536d16d78de7..5372cfcbd054 100644
--- a/drivers/w1/slaves/w1_therm.c
+++ b/drivers/w1/slaves/w1_therm.c
@@ -29,7 +29,6 @@
 #include <linux/delay.h>
 
 #include "../w1.h"
-#include "../w1_io.h"
 #include "../w1_int.h"
 #include "../w1_family.h"
 
@@ -166,12 +165,7 @@ static ssize_t w1_therm_read_bin(struct kobject *kobj, char *buf, loff_t off, si
         u8 rom[9], crc, verdict;
         int i, max_trying = 10;
 
-        atomic_inc(&sl->refcnt);
-        smp_mb__after_atomic_inc();
-        if (down_interruptible(&sl->master->mutex)) {
-                count = 0;
-                goto out_dec;
-        }
+        mutex_lock(&sl->master->mutex);
 
         if (off > W1_SLAVE_DATA_SIZE) {
                 count = 0;
@@ -234,10 +228,7 @@ static ssize_t w1_therm_read_bin(struct kobject *kobj, char *buf, loff_t off, si
 
         count += sprintf(buf + count, "t=%d\n", w1_convert_temp(rom, sl->family->fid));
 out:
-        up(&dev->mutex);
-out_dec:
-        smp_mb__before_atomic_inc();
-        atomic_dec(&sl->refcnt);
+        mutex_unlock(&dev->mutex);
 
         return count;
 }
diff --git a/drivers/w1/w1.c b/drivers/w1/w1.c
index a698b517e863..de3e9791f80d 100644
--- a/drivers/w1/w1.c
+++ b/drivers/w1/w1.c
@@ -35,7 +35,6 @@
 #include <asm/atomic.h>
 
 #include "w1.h"
-#include "w1_io.h"
 #include "w1_log.h"
 #include "w1_int.h"
 #include "w1_family.h"
@@ -55,7 +54,7 @@ module_param_named(control_timeout, w1_control_timeout, int, 0);
 module_param_named(max_slave_count, w1_max_slave_count, int, 0);
 module_param_named(slave_ttl, w1_max_slave_ttl, int, 0);
 
-DEFINE_SPINLOCK(w1_mlock);
+DEFINE_MUTEX(w1_mlock);
 LIST_HEAD(w1_masters);
 
 static struct task_struct *w1_control_thread;
@@ -75,8 +74,6 @@ static void w1_master_release(struct device *dev)
         struct w1_master *md = dev_to_w1_master(dev);
 
         dev_dbg(dev, "%s: Releasing %s.\n", __func__, md->name);
-
-        dev_fini_netlink(md);
         memset(md, 0, sizeof(struct w1_master) + sizeof(struct w1_bus_master));
         kfree(md);
 }
@@ -85,10 +82,10 @@ static void w1_slave_release(struct device *dev)
 {
         struct w1_slave *sl = dev_to_w1_slave(dev);
 
-        dev_dbg(dev, "%s: Releasing %s.\n", __func__, sl->name);
+        printk("%s: Releasing %s.\n", __func__, sl->name);
 
         while (atomic_read(&sl->refcnt)) {
-                dev_dbg(dev, "Waiting for %s to become free: refcnt=%d.\n",
+                printk("Waiting for %s to become free: refcnt=%d.\n",
                                 sl->name, atomic_read(&sl->refcnt));
                 if (msleep_interruptible(1000))
                         flush_signals(current);
@@ -111,7 +108,6 @@ static ssize_t w1_slave_read_id(struct kobject *kobj, char *buf, loff_t off, siz
 {
         struct w1_slave *sl = kobj_to_w1_slave(kobj);
 
-        atomic_inc(&sl->refcnt);
         if (off > 8) {
                 count = 0;
         } else {
@@ -120,7 +116,6 @@ static ssize_t w1_slave_read_id(struct kobject *kobj, char *buf, loff_t off, siz
 
                 memcpy(buf, (u8 *)&sl->reg_num, count);
         }
-        atomic_dec(&sl->refcnt);
 
         return count;
 }
@@ -139,7 +134,63 @@ static struct bin_attribute w1_slave_attr_bin_id = {
 };
 
 /* Default family */
-static struct w1_family w1_default_family;
+
+static ssize_t w1_default_write(struct kobject *kobj, char *buf, loff_t off, size_t count)
+{
+        struct w1_slave *sl = kobj_to_w1_slave(kobj);
+
+        mutex_lock(&sl->master->mutex);
+        if (w1_reset_select_slave(sl)) {
+                count = 0;
+                goto out_up;
+        }
+
+        w1_write_block(sl->master, buf, count);
+
+out_up:
+        mutex_unlock(&sl->master->mutex);
+        return count;
+}
+
+static ssize_t w1_default_read(struct kobject *kobj, char *buf, loff_t off, size_t count)
+{
+        struct w1_slave *sl = kobj_to_w1_slave(kobj);
+
+        mutex_lock(&sl->master->mutex);
+        w1_read_block(sl->master, buf, count);
+        mutex_unlock(&sl->master->mutex);
+        return count;
+}
+
+static struct bin_attribute w1_default_attr = {
+      .attr = {
+              .name = "rw",
+              .mode = S_IRUGO | S_IWUSR,
+              .owner = THIS_MODULE,
+      },
+      .size = PAGE_SIZE,
+      .read = w1_default_read,
+      .write = w1_default_write,
+};
+
+static int w1_default_add_slave(struct w1_slave *sl)
+{
+        return sysfs_create_bin_file(&sl->dev.kobj, &w1_default_attr);
+}
+
+static void w1_default_remove_slave(struct w1_slave *sl)
+{
+        sysfs_remove_bin_file(&sl->dev.kobj, &w1_default_attr);
+}
+
+static struct w1_family_ops w1_default_fops = {
+        .add_slave      = w1_default_add_slave,
+        .remove_slave   = w1_default_remove_slave,
+};
+
+static struct w1_family w1_default_family = {
+        .fops = &w1_default_fops,
+};
 
 static int w1_uevent(struct device *dev, char **envp, int num_envp, char *buffer, int buffer_size);
 
@@ -183,12 +234,9 @@ static ssize_t w1_master_attribute_show_name(struct device *dev, struct device_a
         struct w1_master *md = dev_to_w1_master(dev);
         ssize_t count;
 
-        if (down_interruptible (&md->mutex))
-                return -EBUSY;
-
+        mutex_lock(&md->mutex);
         count = sprintf(buf, "%s\n", md->name);
-
-        up(&md->mutex);
+        mutex_unlock(&md->mutex);
 
         return count;
 }
@@ -199,12 +247,9 @@ static ssize_t w1_master_attribute_store_search(struct device * dev,
 {
         struct w1_master *md = dev_to_w1_master(dev);
 
-        if (down_interruptible (&md->mutex))
-                return -EBUSY;
-
+        mutex_lock(&md->mutex);
         md->search_count = simple_strtol(buf, NULL, 0);
-
-        up(&md->mutex);
+        mutex_unlock(&md->mutex);
 
         return count;
 }
@@ -216,12 +261,9 @@ static ssize_t w1_master_attribute_show_search(struct device *dev,
         struct w1_master *md = dev_to_w1_master(dev);
         ssize_t count;
 
-        if (down_interruptible (&md->mutex))
-                return -EBUSY;
-
+        mutex_lock(&md->mutex);
         count = sprintf(buf, "%d\n", md->search_count);
-
-        up(&md->mutex);
+        mutex_unlock(&md->mutex);
 
         return count;
 }
@@ -231,12 +273,9 @@ static ssize_t w1_master_attribute_show_pointer(struct device *dev, struct devic
         struct w1_master *md = dev_to_w1_master(dev);
         ssize_t count;
 
-        if (down_interruptible(&md->mutex))
-                return -EBUSY;
-
+        mutex_lock(&md->mutex);
         count = sprintf(buf, "0x%p\n", md->bus_master);
-
-        up(&md->mutex);
+        mutex_unlock(&md->mutex);
         return count;
 }
 
@@ -252,12 +291,9 @@ static ssize_t w1_master_attribute_show_max_slave_count(struct device *dev, stru
         struct w1_master *md = dev_to_w1_master(dev);
         ssize_t count;
 
-        if (down_interruptible(&md->mutex))
-                return -EBUSY;
-
+        mutex_lock(&md->mutex);
         count = sprintf(buf, "%d\n", md->max_slave_count);
-
-        up(&md->mutex);
+        mutex_unlock(&md->mutex);
         return count;
 }
 
@@ -266,12 +302,9 @@ static ssize_t w1_master_attribute_show_attempts(struct device *dev, struct devi
         struct w1_master *md = dev_to_w1_master(dev);
         ssize_t count;
 
-        if (down_interruptible(&md->mutex))
-                return -EBUSY;
-
+        mutex_lock(&md->mutex);
         count = sprintf(buf, "%lu\n", md->attempts);
-
-        up(&md->mutex);
+        mutex_unlock(&md->mutex);
         return count;
 }
 
@@ -280,12 +313,9 @@ static ssize_t w1_master_attribute_show_slave_count(struct device *dev, struct d
         struct w1_master *md = dev_to_w1_master(dev);
         ssize_t count;
 
-        if (down_interruptible(&md->mutex))
-                return -EBUSY;
-
+        mutex_lock(&md->mutex);
         count = sprintf(buf, "%d\n", md->slave_count);
-
-        up(&md->mutex);
+        mutex_unlock(&md->mutex);
         return count;
 }
 
@@ -294,8 +324,7 @@ static ssize_t w1_master_attribute_show_slaves(struct device *dev, struct device
         struct w1_master *md = dev_to_w1_master(dev);
         int c = PAGE_SIZE;
 
-        if (down_interruptible(&md->mutex))
-                return -EBUSY;
+        mutex_lock(&md->mutex);
 
         if (md->slave_count == 0)
                 c -= snprintf(buf + PAGE_SIZE - c, c, "not found.\n");
@@ -310,7 +339,7 @@ static ssize_t w1_master_attribute_show_slaves(struct device *dev, struct device
                 }
         }
 
-        up(&md->mutex);
+        mutex_unlock(&md->mutex);
 
         return PAGE_SIZE - c;
 }
@@ -362,7 +391,8 @@ static void w1_destroy_master_attributes(struct w1_master *master)
 }
 
 #ifdef CONFIG_HOTPLUG
-static int w1_uevent(struct device *dev, char **envp, int num_envp, char *buffer, int buffer_size)
+static int w1_uevent(struct device *dev, char **envp, int num_envp,
+                        char *buffer, int buffer_size)
 {
         struct w1_master *md = NULL;
         struct w1_slave *sl = NULL;
@@ -382,7 +412,8 @@ static int w1_uevent(struct device *dev, char **envp, int num_envp, char *buffer
                 return -EINVAL;
         }
 
-        dev_dbg(dev, "Hotplug event for %s %s, bus_id=%s.\n", event_owner, name, dev->bus_id);
+        dev_dbg(dev, "Hotplug event for %s %s, bus_id=%s.\n",
+                        event_owner, name, dev->bus_id);
 
         if (dev->driver != &w1_slave_driver || !sl)
                 return 0;
@@ -401,7 +432,8 @@ static int w1_uevent(struct device *dev, char **envp, int num_envp, char *buffer
         return 0;
 };
 #else
-static int w1_uevent(struct device *dev, char **envp, int num_envp, char *buffer, int buffer_size)
+static int w1_uevent(struct device *dev, char **envp, int num_envp,
+                        char *buffer, int buffer_size)
 {
         return 0;
 }
@@ -425,7 +457,8 @@ static int __w1_attach_slave_device(struct w1_slave *sl)
                  (unsigned int) sl->reg_num.family,
                  (unsigned long long) sl->reg_num.id);
 
-        dev_dbg(&sl->dev, "%s: registering %s as %p.\n", __func__, &sl->dev.bus_id[0]);
+        dev_dbg(&sl->dev, "%s: registering %s as %p.\n", __func__,
+                &sl->dev.bus_id[0]);
 
         err = device_register(&sl->dev);
         if (err < 0) {
@@ -496,6 +529,7 @@ static int w1_attach_slave_device(struct w1_master *dev, struct w1_reg_num *rn)
         sl->master = dev;
         set_bit(W1_SLAVE_ACTIVE, (long *)&sl->flags);
 
+        memset(&msg, 0, sizeof(msg));
         memcpy(&sl->reg_num, rn, sizeof(sl->reg_num));
         atomic_set(&sl->refcnt, 0);
         init_completion(&sl->released);
@@ -526,7 +560,7 @@ static int w1_attach_slave_device(struct w1_master *dev, struct w1_reg_num *rn)
         sl->ttl = dev->slave_ttl;
         dev->slave_count++;
 
-        memcpy(&msg.id.id, rn, sizeof(msg.id.id));
+        memcpy(msg.id.id, rn, sizeof(msg.id));
         msg.type = W1_SLAVE_ADD;
         w1_netlink_send(dev, &msg);
 
@@ -544,7 +578,8 @@ static void w1_slave_detach(struct w1_slave *sl)
         if (sl->family->fops && sl->family->fops->remove_slave)
                 sl->family->fops->remove_slave(sl);
 
-        memcpy(&msg.id.id, &sl->reg_num, sizeof(msg.id.id));
+        memset(&msg, 0, sizeof(msg));
+        memcpy(msg.id.id, &sl->reg_num, sizeof(msg.id));
         msg.type = W1_SLAVE_REMOVE;
         w1_netlink_send(sl->master, &msg);
 
@@ -561,7 +596,7 @@ static struct w1_master *w1_search_master(void *data)
         struct w1_master *dev;
         int found = 0;
 
-        spin_lock_bh(&w1_mlock);
+        mutex_lock(&w1_mlock);
         list_for_each_entry(dev, &w1_masters, w1_master_entry) {
                 if (dev->bus_master->data == data) {
                         found = 1;
@@ -569,22 +604,69 @@ static struct w1_master *w1_search_master(void *data)
                         break;
                 }
         }
-        spin_unlock_bh(&w1_mlock);
+        mutex_unlock(&w1_mlock);
+
+        return (found)?dev:NULL;
+}
+
+struct w1_master *w1_search_master_id(u32 id)
+{
+        struct w1_master *dev;
+        int found = 0;
+
+        mutex_lock(&w1_mlock);
+        list_for_each_entry(dev, &w1_masters, w1_master_entry) {
+                if (dev->id == id) {
+                        found = 1;
+                        atomic_inc(&dev->refcnt);
+                        break;
+                }
+        }
+        mutex_unlock(&w1_mlock);
 
         return (found)?dev:NULL;
 }
 
+struct w1_slave *w1_search_slave(struct w1_reg_num *id)
+{
+        struct w1_master *dev;
+        struct w1_slave *sl = NULL;
+        int found = 0;
+
+        mutex_lock(&w1_mlock);
+        list_for_each_entry(dev, &w1_masters, w1_master_entry) {
+                mutex_lock(&dev->mutex);
+                list_for_each_entry(sl, &dev->slist, w1_slave_entry) {
+                        if (sl->reg_num.family == id->family &&
+                                        sl->reg_num.id == id->id &&
+                                        sl->reg_num.crc == id->crc) {
+                                found = 1;
+                                atomic_inc(&dev->refcnt);
+                                atomic_inc(&sl->refcnt);
+                                break;
+                        }
+                }
+                mutex_unlock(&dev->mutex);
+
+                if (found)
+                        break;
+        }
+        mutex_unlock(&w1_mlock);
+
+        return (found)?sl:NULL;
+}
+
 void w1_reconnect_slaves(struct w1_family *f)
 {
         struct w1_master *dev;
 
-        spin_lock_bh(&w1_mlock);
+        mutex_lock(&w1_mlock);
         list_for_each_entry(dev, &w1_masters, w1_master_entry) {
                 dev_dbg(&dev->dev, "Reconnecting slaves in %s into new family %02x.\n",
                                 dev->name, f->fid);
                 set_bit(W1_MASTER_NEED_RECONNECT, &dev->flags);
         }
-        spin_unlock_bh(&w1_mlock);
+        mutex_unlock(&w1_mlock);
 }
 
 static void w1_slave_found(void *data, u64 rn)
@@ -646,7 +728,7 @@ static void w1_slave_found(void *data, u64 rn)
  * @dev        The master device to search
  * @cb         Function to call when a device is found
  */
-void w1_search(struct w1_master *dev, w1_slave_found_callback cb)
+void w1_search(struct w1_master *dev, u8 search_type, w1_slave_found_callback cb)
 {
         u64 last_rn, rn, tmp64;
         int i, slave_count = 0;
@@ -677,7 +759,7 @@ void w1_search(struct w1_master *dev, w1_slave_found_callback cb)
                 }
 
                 /* Start the search */
-                w1_write_8(dev, W1_SEARCH);
+                w1_write_8(dev, search_type);
                 for (i = 0; i < 64; ++i) {
                         /* Determine the direction/search bit */
                         if (i == desc_bit)
@@ -739,23 +821,23 @@ static int w1_control(void *data)
                         if (kthread_should_stop() || test_bit(W1_MASTER_NEED_EXIT, &dev->flags)) {
                                 set_bit(W1_MASTER_NEED_EXIT, &dev->flags);
 
-                                spin_lock(&w1_mlock);
+                                mutex_lock(&w1_mlock);
                                 list_del(&dev->w1_master_entry);
-                                spin_unlock(&w1_mlock);
+                                mutex_unlock(&w1_mlock);
 
-                                down(&dev->mutex);
+                                mutex_lock(&dev->mutex);
                                 list_for_each_entry_safe(sl, sln, &dev->slist, w1_slave_entry) {
                                         w1_slave_detach(sl);
                                 }
                                 w1_destroy_master_attributes(dev);
-                                up(&dev->mutex);
+                                mutex_unlock(&dev->mutex);
                                 atomic_dec(&dev->refcnt);
                                 continue;
                         }
 
                         if (test_bit(W1_MASTER_NEED_RECONNECT, &dev->flags)) {
                                 dev_dbg(&dev->dev, "Reconnecting slaves in device %s.\n", dev->name);
-                                down(&dev->mutex);
+                                mutex_lock(&dev->mutex);
                                 list_for_each_entry_safe(sl, sln, &dev->slist, w1_slave_entry) {
                                         if (sl->family->fid == W1_FAMILY_DEFAULT) {
                                                 struct w1_reg_num rn;
@@ -768,7 +850,7 @@ static int w1_control(void *data)
                                 }
                                 dev_dbg(&dev->dev, "Reconnecting slaves in device %s has been finished.\n", dev->name);
                                 clear_bit(W1_MASTER_NEED_RECONNECT, &dev->flags);
-                                up(&dev->mutex);
+                                mutex_unlock(&dev->mutex);
                         }
                 }
         }
@@ -776,10 +858,31 @@ static int w1_control(void *data)
         return 0;
 }
 
+void w1_search_process(struct w1_master *dev, u8 search_type)
+{
+        struct w1_slave *sl, *sln;
+
+        list_for_each_entry(sl, &dev->slist, w1_slave_entry)
+                clear_bit(W1_SLAVE_ACTIVE, (long *)&sl->flags);
+
+        w1_search_devices(dev, search_type, w1_slave_found);
+
+        list_for_each_entry_safe(sl, sln, &dev->slist, w1_slave_entry) {
+                if (!test_bit(W1_SLAVE_ACTIVE, (unsigned long *)&sl->flags) && !--sl->ttl) {
+                        w1_slave_detach(sl);
+
+                        dev->slave_count--;
+                } else if (test_bit(W1_SLAVE_ACTIVE, (unsigned long *)&sl->flags))
+                        sl->ttl = dev->slave_ttl;
+        }
+
+        if (dev->search_count > 0)
+                dev->search_count--;
+}
+
 int w1_process(void *data)
 {
         struct w1_master *dev = (struct w1_master *) data;
-        struct w1_slave *sl, *sln;
 
         while (!kthread_should_stop() && !test_bit(W1_MASTER_NEED_EXIT, &dev->flags)) {
                 try_to_freeze();
@@ -794,27 +897,9 @@ int w1_process(void *data)
                 if (dev->search_count == 0)
                         continue;
 
-                if (down_interruptible(&dev->mutex))
-                        continue;
-
-                list_for_each_entry(sl, &dev->slist, w1_slave_entry)
-                        clear_bit(W1_SLAVE_ACTIVE, (long *)&sl->flags);
-
-                w1_search_devices(dev, w1_slave_found);
-
-                list_for_each_entry_safe(sl, sln, &dev->slist, w1_slave_entry) {
-                        if (!test_bit(W1_SLAVE_ACTIVE, (unsigned long *)&sl->flags) && !--sl->ttl) {
-                                w1_slave_detach(sl);
-
-                                dev->slave_count--;
-                        } else if (test_bit(W1_SLAVE_ACTIVE, (unsigned long *)&sl->flags))
-                                sl->ttl = dev->slave_ttl;
-                }
-
-                if (dev->search_count > 0)
-                        dev->search_count--;
-
-                up(&dev->mutex);
+                mutex_lock(&dev->mutex);
+                w1_search_process(dev, W1_SEARCH);
+                mutex_unlock(&dev->mutex);
         }
 
         atomic_dec(&dev->refcnt);
@@ -828,6 +913,8 @@ static int w1_init(void)
 
         printk(KERN_INFO "Driver for 1-wire Dallas network protocol.\n");
 
+        w1_init_netlink();
+
         retval = bus_register(&w1_bus_type);
         if (retval) {
                 printk(KERN_ERR "Failed to register bus. err=%d.\n", retval);
@@ -880,6 +967,8 @@ static void w1_fini(void)
         list_for_each_entry(dev, &w1_masters, w1_master_entry)
                 __w1_remove_master_device(dev);
 
+        w1_fini_netlink();
+
         kthread_stop(w1_control_thread);
 
         driver_unregister(&w1_slave_driver);
diff --git a/drivers/w1/w1.h b/drivers/w1/w1.h
index 56980505e6c4..f1df5343f4ad 100644
--- a/drivers/w1/w1.h
+++ b/drivers/w1/w1.h
@@ -41,10 +41,7 @@ struct w1_reg_num
 
 #include <linux/completion.h>
 #include <linux/device.h>
-
-#include <net/sock.h>
-
-#include <asm/semaphore.h>
+#include <linux/mutex.h>
 
 #include "w1_family.h"
 
@@ -52,7 +49,7 @@ struct w1_reg_num
 #define W1_SLAVE_DATA_SIZE      128
 
 #define W1_SEARCH               0xF0
-#define W1_CONDITIONAL_SEARCH   0xEC
+#define W1_ALARM_SEARCH         0xEC
 #define W1_CONVERT_TEMP         0x44
 #define W1_SKIP_ROM             0xCC
 #define W1_READ_SCRATCHPAD      0xBE
@@ -60,7 +57,7 @@ struct w1_reg_num
 #define W1_READ_PSUPPLY         0xB4
 #define W1_MATCH_ROM            0x55
 
-#define W1_SLAVE_ACTIVE         (1<<0)
+#define W1_SLAVE_ACTIVE         0
 
 struct w1_slave
 {
@@ -145,8 +142,8 @@ struct w1_bus_master
          */
         u8              (*reset_bus)(void *);
 
-        /** Really nice hardware can handles the ROM searches */
-        void            (*search)(void *, w1_slave_found_callback);
+        /** Really nice hardware can handles the different types of ROM search */
+        void            (*search)(void *, u8, w1_slave_found_callback);
 };
 
 #define W1_MASTER_NEED_EXIT             0
@@ -173,19 +170,30 @@ struct w1_master
         long                    flags;
 
         struct task_struct      *thread;
-        struct semaphore        mutex;
+        struct mutex            mutex;
 
         struct device_driver    *driver;
         struct device           dev;
 
         struct w1_bus_master    *bus_master;
 
-        u32                     seq, groups;
-        struct sock             *nls;
+        u32                     seq;
 };
 
 int w1_create_master_attributes(struct w1_master *);
-void w1_search(struct w1_master *dev, w1_slave_found_callback cb);
+void w1_search(struct w1_master *dev, u8 search_type, w1_slave_found_callback cb);
+void w1_search_devices(struct w1_master *dev, u8 search_type, w1_slave_found_callback cb);
+struct w1_slave *w1_search_slave(struct w1_reg_num *id);
+void w1_search_process(struct w1_master *dev, u8 search_type);
+struct w1_master *w1_search_master_id(u32 id);
+
+u8 w1_triplet(struct w1_master *dev, int bdir);
+void w1_write_8(struct w1_master *, u8);
+int w1_reset_bus(struct w1_master *);
+u8 w1_calc_crc8(u8 *, int);
+void w1_write_block(struct w1_master *, const u8 *, int);
+u8 w1_read_block(struct w1_master *, u8 *, int);
+int w1_reset_select_slave(struct w1_slave *sl);
 
 static inline struct w1_slave* dev_to_w1_slave(struct device *dev)
 {
@@ -202,15 +210,14 @@ static inline struct w1_master* dev_to_w1_master(struct device *dev)
         return container_of(dev, struct w1_master, dev);
 }
 
+extern struct device_driver w1_master_driver;
+extern struct device w1_master_device;
 extern int w1_max_slave_count;
 extern int w1_max_slave_ttl;
-extern spinlock_t w1_mlock;
 extern struct list_head w1_masters;
-extern struct device_driver w1_master_driver;
-extern struct device w1_master_device;
+extern struct mutex w1_mlock;
 
-int w1_process(void *data);
-void w1_reconnect_slaves(struct w1_family *f);
+extern int w1_process(void *);
 
 #endif /* __KERNEL__ */
 
diff --git a/drivers/w1/w1_family.c b/drivers/w1/w1_family.c
index 0e32c114f906..a3c95bd6890a 100644
--- a/drivers/w1/w1_family.c
+++ b/drivers/w1/w1_family.c
@@ -107,6 +107,12 @@ struct w1_family * w1_family_registered(u8 fid)
         return (ret) ? f : NULL;
 }
 
+static void __w1_family_put(struct w1_family *f)
+{
+        if (atomic_dec_and_test(&f->refcnt))
+                f->need_exit = 1;
+}
+
 void w1_family_put(struct w1_family *f)
 {
         spin_lock(&w1_flock);
@@ -114,19 +120,14 @@ void w1_family_put(struct w1_family *f)
         spin_unlock(&w1_flock);
 }
 
-void __w1_family_put(struct w1_family *f)
-{
-        if (atomic_dec_and_test(&f->refcnt))
-                f->need_exit = 1;
-}
-
+#if 0
 void w1_family_get(struct w1_family *f)
 {
         spin_lock(&w1_flock);
         __w1_family_get(f);
         spin_unlock(&w1_flock);
-
 }
+#endif  /*  0  */
 
 void __w1_family_get(struct w1_family *f)
 {
@@ -135,8 +136,5 @@ void __w1_family_get(struct w1_family *f)
         smp_mb__after_atomic_inc();
 }
 
-EXPORT_SYMBOL(w1_family_get);
-EXPORT_SYMBOL(w1_family_put);
-EXPORT_SYMBOL(w1_family_registered);
 EXPORT_SYMBOL(w1_unregister_family);
 EXPORT_SYMBOL(w1_register_family);
diff --git a/drivers/w1/w1_family.h b/drivers/w1/w1_family.h
index 2ca0489c716a..1e2ac40c2c14 100644
--- a/drivers/w1/w1_family.h
+++ b/drivers/w1/w1_family.h
@@ -57,12 +57,11 @@ struct w1_family
 
 extern spinlock_t w1_flock;
 
-void w1_family_get(struct w1_family *);
 void w1_family_put(struct w1_family *);
 void __w1_family_get(struct w1_family *);
-void __w1_family_put(struct w1_family *);
 struct w1_family * w1_family_registered(u8);
 void w1_unregister_family(struct w1_family *);
 int w1_register_family(struct w1_family *);
+void w1_reconnect_slaves(struct w1_family *f);
 
 #endif /* __W1_FAMILY_H */
diff --git a/drivers/w1/w1_int.c b/drivers/w1/w1_int.c
index 68565aacec7b..357a2e0f637a 100644
--- a/drivers/w1/w1_int.c
+++ b/drivers/w1/w1_int.c
@@ -65,7 +65,7 @@ static struct w1_master * w1_alloc_dev(u32 id, int slave_count, int slave_ttl,
         atomic_set(&dev->refcnt, 2);
 
         INIT_LIST_HEAD(&dev->slist);
-        init_MUTEX(&dev->mutex);
+        mutex_init(&dev->mutex);
 
         memcpy(&dev->dev, device, sizeof(struct device));
         snprintf(dev->dev.bus_id, sizeof(dev->dev.bus_id),
@@ -74,16 +74,11 @@ static struct w1_master * w1_alloc_dev(u32 id, int slave_count, int slave_ttl,
 
         dev->driver = driver;
 
-        dev->groups = 1;
         dev->seq = 1;
-        dev_init_netlink(dev);
 
         err = device_register(&dev->dev);
         if (err) {
                 printk(KERN_ERR "Failed to register master device. err=%d\n", err);
-
-                dev_fini_netlink(dev);
-
                 memset(dev, 0, sizeof(struct w1_master));
                 kfree(dev);
                 dev = NULL;
@@ -131,12 +126,12 @@ int w1_add_master_device(struct w1_bus_master *master)
 
         dev->initialized = 1;
 
-        spin_lock(&w1_mlock);
+        mutex_lock(&w1_mlock);
         list_add(&dev->w1_master_entry, &w1_masters);
-        spin_unlock(&w1_mlock);
+        mutex_unlock(&w1_mlock);
 
+        memset(&msg, 0, sizeof(msg));
         msg.id.mst.id = dev->id;
-        msg.id.mst.pid = dev->thread->pid;
         msg.type = W1_MASTER_ADD;
         w1_netlink_send(dev, &msg);
 
@@ -153,7 +148,6 @@ err_out_free_dev:
 void __w1_remove_master_device(struct w1_master *dev)
 {
         struct w1_netlink_msg msg;
-        pid_t pid = dev->thread->pid;
 
         set_bit(W1_MASTER_NEED_EXIT, &dev->flags);
         kthread_stop(dev->thread);
@@ -166,8 +160,8 @@ void __w1_remove_master_device(struct w1_master *dev)
                         flush_signals(current);
         }
 
+        memset(&msg, 0, sizeof(msg));
         msg.id.mst.id = dev->id;
-        msg.id.mst.pid = pid;
         msg.type = W1_MASTER_REMOVE;
         w1_netlink_send(dev, &msg);
 
diff --git a/drivers/w1/w1_io.c b/drivers/w1/w1_io.c
index f7f7e8bec30e..30b6fbf83bd4 100644
--- a/drivers/w1/w1_io.c
+++ b/drivers/w1/w1_io.c
@@ -23,10 +23,10 @@
 
 #include <linux/delay.h>
 #include <linux/moduleparam.h>
+#include <linux/module.h>
 
 #include "w1.h"
 #include "w1_log.h"
-#include "w1_io.h"
 
 static int w1_delay_parm = 1;
 module_param_named(delay_coef, w1_delay_parm, int, 0);
@@ -50,7 +50,7 @@ static u8 w1_crc8_table[] = {
         116, 42, 200, 150, 21, 75, 169, 247, 182, 232, 10, 84, 215, 137, 107, 53
 };
 
-void w1_delay(unsigned long tm)
+static void w1_delay(unsigned long tm)
 {
         udelay(tm * w1_delay_parm);
 }
@@ -61,7 +61,7 @@ static u8 w1_read_bit(struct w1_master *dev);
 /**
  * Generates a write-0 or write-1 cycle and samples the level.
  */
-u8 w1_touch_bit(struct w1_master *dev, int bit)
+static u8 w1_touch_bit(struct w1_master *dev, int bit)
 {
         if (dev->bus_master->touch_bit)
                 return dev->bus_master->touch_bit(dev->bus_master->data, bit);
@@ -108,6 +108,7 @@ void w1_write_8(struct w1_master *dev, u8 byte)
                 for (i = 0; i < 8; ++i)
                         w1_touch_bit(dev, (byte >> i) & 0x1);
 }
+EXPORT_SYMBOL_GPL(w1_write_8);
 
 
 /**
@@ -176,7 +177,7 @@ u8 w1_triplet(struct w1_master *dev, int bdir)
  * @param dev     the master device
  * @return        the byte read
  */
-u8 w1_read_8(struct w1_master * dev)
+static u8 w1_read_8(struct w1_master * dev)
 {
         int i;
         u8 res = 0;
@@ -208,6 +209,7 @@ void w1_write_block(struct w1_master *dev, const u8 *buf, int len)
                 for (i = 0; i < len; ++i)
                         w1_write_8(dev, buf[i]);
 }
+EXPORT_SYMBOL_GPL(w1_write_block);
 
 /**
  * Reads a series of bytes.
@@ -232,6 +234,7 @@ u8 w1_read_block(struct w1_master *dev, u8 *buf, int len)
 
         return ret;
 }
+EXPORT_SYMBOL_GPL(w1_read_block);
 
 /**
  * Issues a reset bus sequence.
@@ -257,6 +260,7 @@ int w1_reset_bus(struct w1_master *dev)
 
         return result;
 }
+EXPORT_SYMBOL_GPL(w1_reset_bus);
 
 u8 w1_calc_crc8(u8 * data, int len)
 {
@@ -267,14 +271,15 @@ u8 w1_calc_crc8(u8 * data, int len)
 
         return crc;
 }
+EXPORT_SYMBOL_GPL(w1_calc_crc8);
 
-void w1_search_devices(struct w1_master *dev, w1_slave_found_callback cb)
+void w1_search_devices(struct w1_master *dev, u8 search_type, w1_slave_found_callback cb)
 {
         dev->attempts++;
         if (dev->bus_master->search)
-                dev->bus_master->search(dev->bus_master->data, cb);
+                dev->bus_master->search(dev->bus_master->data, search_type, cb);
         else
-                w1_search(dev, cb);
+                w1_search(dev, search_type, cb);
 }
 
 /**
@@ -299,14 +304,4 @@ int w1_reset_select_slave(struct w1_slave *sl)
         }
         return 0;
 }
-
-EXPORT_SYMBOL(w1_touch_bit);
-EXPORT_SYMBOL(w1_write_8);
-EXPORT_SYMBOL(w1_read_8);
-EXPORT_SYMBOL(w1_reset_bus);
-EXPORT_SYMBOL(w1_calc_crc8);
-EXPORT_SYMBOL(w1_delay);
-EXPORT_SYMBOL(w1_read_block);
-EXPORT_SYMBOL(w1_write_block);
-EXPORT_SYMBOL(w1_search_devices);
-EXPORT_SYMBOL(w1_reset_select_slave);
+EXPORT_SYMBOL_GPL(w1_reset_select_slave);
diff --git a/drivers/w1/w1_io.h b/drivers/w1/w1_io.h
index 232860184a29..9a76d2ad69c5 100644
--- a/drivers/w1/w1_io.h
+++ b/drivers/w1/w1_io.h
@@ -24,11 +24,8 @@
 
 #include "w1.h"
 
-void w1_delay(unsigned long);
-u8 w1_touch_bit(struct w1_master *, int);
 u8 w1_triplet(struct w1_master *dev, int bdir);
 void w1_write_8(struct w1_master *, u8);
-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);
diff --git a/drivers/w1/w1_netlink.c b/drivers/w1/w1_netlink.c
index 328645da7972..65c5ebd0787e 100644
--- a/drivers/w1/w1_netlink.c
+++ b/drivers/w1/w1_netlink.c
@@ -21,72 +21,225 @@
 
 #include <linux/skbuff.h>
 #include <linux/netlink.h>
+#include <linux/connector.h>
 
 #include "w1.h"
 #include "w1_log.h"
 #include "w1_netlink.h"
 
-#ifndef NETLINK_DISABLED
+#if defined(CONFIG_W1_CON) && (defined(CONFIG_CONNECTOR) || (defined(CONFIG_CONNECTOR_MODULE) && defined(CONFIG_W1_MODULE)))
 void w1_netlink_send(struct w1_master *dev, struct w1_netlink_msg *msg)
 {
-        unsigned int size;
-        struct sk_buff *skb;
-        struct w1_netlink_msg *data;
-        struct nlmsghdr *nlh;
+        char buf[sizeof(struct cn_msg) + sizeof(struct w1_netlink_msg)];
+        struct cn_msg *m = (struct cn_msg *)buf;
+        struct w1_netlink_msg *w = (struct w1_netlink_msg *)(m+1);
 
-        if (!dev->nls)
-                return;
+        memset(buf, 0, sizeof(buf));
 
-        size = NLMSG_SPACE(sizeof(struct w1_netlink_msg));
+        m->id.idx = CN_W1_IDX;
+        m->id.val = CN_W1_VAL;
 
-        skb = alloc_skb(size, GFP_ATOMIC);
-        if (!skb) {
-                dev_err(&dev->dev, "skb_alloc() failed.\n");
-                return;
-        }
+        m->seq = dev->seq++;
+        m->len = sizeof(struct w1_netlink_msg);
+
+        memcpy(w, msg, sizeof(struct w1_netlink_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)
+{
+        dev_dbg(&dev->dev, "%s: %s: cmd=%02x, len=%u.\n",
+                __func__, dev->name, cmd->cmd, cmd->len);
+
+        if (cmd->cmd != W1_CMD_SEARCH && cmd->cmd != W1_CMD_ALARM_SEARCH)
+                return -EINVAL;
+
+        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)
+{
+        void *data;
+        struct w1_netlink_msg *h;
+        struct w1_netlink_cmd *c;
+        struct cn_msg *cm;
+        int err;
+
+        data = kzalloc(sizeof(struct cn_msg) +
+                        sizeof(struct w1_netlink_msg) +
+                        sizeof(struct w1_netlink_cmd) +
+                        cmd->len, GFP_KERNEL);
+        if (!data)
+                return -ENOMEM;
+
+        cm = (struct cn_msg *)(data);
+        h = (struct w1_netlink_msg *)(cm + 1);
+        c = (struct w1_netlink_cmd *)(h + 1);
+
+        memcpy(cm, msg, sizeof(struct cn_msg));
+        memcpy(h, hdr, sizeof(struct w1_netlink_msg));
+        memcpy(c, cmd, sizeof(struct w1_netlink_cmd));
 
-        nlh = NLMSG_PUT(skb, 0, dev->seq++, NLMSG_DONE, size - sizeof(*nlh));
+        cm->ack = msg->seq+1;
+        cm->len = sizeof(struct w1_netlink_msg) + sizeof(struct w1_netlink_cmd) + cmd->len;
 
-        data = (struct w1_netlink_msg *)NLMSG_DATA(nlh);
+        h->len = sizeof(struct w1_netlink_cmd) + cmd->len;
 
-        memcpy(data, msg, sizeof(struct w1_netlink_msg));
+        memcpy(c->data, cmd->data, c->len);
 
-        NETLINK_CB(skb).dst_group = dev->groups;
-        netlink_broadcast(dev->nls, skb, 0, dev->groups, GFP_ATOMIC);
+        err = cn_netlink_send(cm, 0, GFP_KERNEL);
 
-nlmsg_failure:
-        return;
+        kfree(data);
+
+        return err;
 }
 
-int dev_init_netlink(struct w1_master *dev)
+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->nls = netlink_kernel_create(NETLINK_W1, 1, NULL, THIS_MODULE);
-        if (!dev->nls) {
-                printk(KERN_ERR "Failed to create new netlink socket(%u) for w1 master %s.\n",
-                        NETLINK_W1, dev->dev.bus_id);
+        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_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;
         }
 
-        return 0;
+        return err;
 }
 
-void dev_fini_netlink(struct w1_master *dev)
+static void w1_cn_callback(void *data)
 {
-        if (dev->nls && dev->nls->sk_socket)
-                sock_release(dev->nls->sk_socket);
+        struct cn_msg *msg = data;
+        struct w1_netlink_msg *m = (struct w1_netlink_msg *)(msg + 1);
+        struct w1_netlink_cmd *cmd;
+        struct w1_slave *sl;
+        struct w1_master *dev;
+        int err = 0;
+
+        while (msg->len && !err) {
+                struct w1_reg_num id;
+                u16 mlen = m->len;
+                u8 *cmd_data = m->data;
+
+                dev = NULL;
+                sl = NULL;
+
+                memcpy(&id, m->id.id, sizeof(id));
+#if 0
+                printk("%s: %02x.%012llx.%02x: type=%02x, len=%u.\n",
+                                __func__, id.family, (unsigned long long)id.id, id.crc, m->type, m->len);
+#endif
+                if (m->len + sizeof(struct w1_netlink_msg) > msg->len) {
+                        err = -E2BIG;
+                        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;
+                }
+
+                if (!dev) {
+                        err = -ENODEV;
+                        goto out_cont;
+                }
+
+                mutex_lock(&dev->mutex);
+
+                if (sl && w1_reset_select_slave(sl)) {
+                        err = -ENODEV;
+                        goto out_up;
+                }
+
+                while (mlen) {
+                        cmd = (struct w1_netlink_cmd *)cmd_data;
+
+                        if (cmd->len + sizeof(struct w1_netlink_cmd) > mlen) {
+                                err = -E2BIG;
+                                break;
+                        }
+
+                        if (sl)
+                                w1_process_command_slave(sl, msg, m, cmd);
+                        else
+                                w1_process_command_master(dev, msg, m, cmd);
+
+                        cmd_data += cmd->len + sizeof(struct w1_netlink_cmd);
+                        mlen -= cmd->len + sizeof(struct w1_netlink_cmd);
+                }
+out_up:
+                atomic_dec(&dev->refcnt);
+                if (sl)
+                        atomic_dec(&sl->refcnt);
+                mutex_unlock(&dev->mutex);
+out_cont:
+                msg->len -= sizeof(struct w1_netlink_msg) + m->len;
+                m = (struct w1_netlink_msg *)(((u8 *)m) + sizeof(struct w1_netlink_msg) + m->len);
+
+                /*
+                 * Let's allow requests for nonexisting devices.
+                 */
+                if (err == -ENODEV)
+                        err = 0;
+        }
+#if 0
+        if (err) {
+                printk("%s: malformed message. Dropping.\n", __func__);
+        }
+#endif
 }
-#else
-#warning Netlink support is disabled. Please compile with NET support enabled.
 
+int w1_init_netlink(void)
+{
+        struct cb_id w1_id = {.idx = CN_W1_IDX, .val = CN_W1_VAL};
+
+        return cn_add_callback(&w1_id, "w1", &w1_cn_callback);
+}
+
+void w1_fini_netlink(void)
+{
+        struct cb_id w1_id = {.idx = CN_W1_IDX, .val = CN_W1_VAL};
+
+        cn_del_callback(&w1_id);
+}
+#else
 void w1_netlink_send(struct w1_master *dev, struct w1_netlink_msg *msg)
 {
 }
 
-int dev_init_netlink(struct w1_master *dev)
+int w1_init_netlink(void)
 {
         return 0;
 }
 
-void dev_fini_netlink(struct w1_master *dev)
+void w1_fini_netlink(void)
 {
 }
 #endif
diff --git a/drivers/w1/w1_netlink.h b/drivers/w1/w1_netlink.h
index eb0c8b3152c8..56122b9e9294 100644
--- a/drivers/w1/w1_netlink.h
+++ b/drivers/w1/w1_netlink.h
@@ -23,6 +23,7 @@
 #define __W1_NETLINK_H
 
 #include <asm/types.h>
+#include <linux/connector.h>
 
 #include "w1.h"
 
@@ -31,29 +32,43 @@ enum w1_netlink_message_types {
         W1_SLAVE_REMOVE,
         W1_MASTER_ADD,
         W1_MASTER_REMOVE,
+        W1_MASTER_CMD,
+        W1_SLAVE_CMD,
 };
 
 struct w1_netlink_msg
 {
         __u8                            type;
-        __u8                            reserved[3];
-        union
-        {
-                struct w1_reg_num       id;
-                __u64                   w1_id;
-                struct
-                {
+        __u8                            reserved;
+        __u16                           len;
+        union {
+                __u8                    id[8];
+                struct w1_mst {
                         __u32           id;
-                        __u32           pid;
+                        __u32           res;
                 } mst;
         } id;
+        __u8                            data[0];
+};
+
+#define W1_CMD_READ             0x0
+#define W1_CMD_WRITE            0x1
+#define W1_CMD_SEARCH           0x2
+#define W1_CMD_ALARM_SEARCH     0x3
+
+struct w1_netlink_cmd
+{
+        __u8                            cmd;
+        __u8                            res;
+        __u16                           len;
+        __u8                            data[0];
 };
 
 #ifdef __KERNEL__
 
 void w1_netlink_send(struct w1_master *, struct w1_netlink_msg *);
-int dev_init_netlink(struct w1_master *dev);
-void dev_fini_netlink(struct w1_master *dev);
+int w1_init_netlink(void);
+void w1_fini_netlink(void);
 
 #endif /* __KERNEL__ */
 #endif /* __W1_NETLINK_H */