Merge branch 'master'

18 files changed, 116 insertions, 97 deletions

diff --git a/drivers/pci/quirks.c b/drivers/pci/quirks.c
index bbd9c2323d8c..5627ce1d2b32 100644
--- a/drivers/pci/quirks.c
+++ b/drivers/pci/quirks.c
@@ -356,7 +356,7 @@ static void piix4_mem_quirk(struct pci_dev *dev, const char *name, unsigned int
 /*
  * PIIX4 ACPI: Two IO regions pointed to by longwords at
  *      0x40 (64 bytes of ACPI registers)
- *      0x90 (32 bytes of SMB registers)
+ *      0x90 (16 bytes of SMB registers)
  * and a few strange programmable PIIX4 device resources.
  */
 static void __devinit quirk_piix4_acpi(struct pci_dev *dev)
@@ -366,7 +366,7 @@ static void __devinit quirk_piix4_acpi(struct pci_dev *dev)
         pci_read_config_dword(dev, 0x40, &region);
         quirk_io_region(dev, region, 64, PCI_BRIDGE_RESOURCES, "PIIX4 ACPI");
         pci_read_config_dword(dev, 0x90, &region);
-        quirk_io_region(dev, region, 32, PCI_BRIDGE_RESOURCES+1, "PIIX4 SMB");
+        quirk_io_region(dev, region, 16, PCI_BRIDGE_RESOURCES+1, "PIIX4 SMB");
 
         /* Device resource A has enables for some of the other ones */
         pci_read_config_dword(dev, 0x5c, &res_a);
diff --git a/drivers/scsi/ahci.c b/drivers/scsi/ahci.c
index 25a47d7afa28..8420204c2eaa 100644
--- a/drivers/scsi/ahci.c
+++ b/drivers/scsi/ahci.c
@@ -41,6 +41,7 @@
 #include <linux/interrupt.h>
 #include <linux/sched.h>
 #include <linux/dma-mapping.h>
+#include <linux/device.h>
 #include "scsi.h"
 #include <scsi/scsi_host.h>
 #include <linux/libata.h>
@@ -682,10 +683,10 @@ static irqreturn_t ahci_interrupt (int irq, void *dev_instance, struct pt_regs *
                         if (!ahci_host_intr(ap, qc))
                                 if (ata_ratelimit()) {
                                         struct pci_dev *pdev =
-                                          to_pci_dev(ap->host_set->dev);
-                                        printk(KERN_WARNING
-                                          "ahci(%s): unhandled interrupt on port %u\n",
-                                          pci_name(pdev), i);
+                                                to_pci_dev(ap->host_set->dev);
+                                        dev_printk(KERN_WARNING, &pdev->dev,
+                                          "unhandled interrupt on port %u\n",
+                                          i);
                                 }
 
                         VPRINTK("port %u\n", i);
@@ -693,10 +694,9 @@ static irqreturn_t ahci_interrupt (int irq, void *dev_instance, struct pt_regs *
                         VPRINTK("port %u (no irq)\n", i);
                         if (ata_ratelimit()) {
                                 struct pci_dev *pdev =
-                                  to_pci_dev(ap->host_set->dev);
-                                printk(KERN_WARNING
-                                  "ahci(%s): interrupt on disabled port %u\n",
-                                  pci_name(pdev), i);
+                                        to_pci_dev(ap->host_set->dev);
+                                dev_printk(KERN_WARNING, &pdev->dev,
+                                        "interrupt on disabled port %u\n", i);
                         }
                 }
 
@@ -768,8 +768,8 @@ static int ahci_host_init(struct ata_probe_ent *probe_ent)
 
         tmp = readl(mmio + HOST_CTL);
         if (tmp & HOST_RESET) {
-                printk(KERN_ERR DRV_NAME "(%s): controller reset failed (0x%x)\n",
-                        pci_name(pdev), tmp);
+                dev_printk(KERN_ERR, &pdev->dev,
+                           "controller reset failed (0x%x)\n", tmp);
                 return -EIO;
         }
 
@@ -797,22 +797,22 @@ static int ahci_host_init(struct ata_probe_ent *probe_ent)
                 if (rc) {
                         rc = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
                         if (rc) {
-                                printk(KERN_ERR DRV_NAME "(%s): 64-bit DMA enable failed\n",
-                                        pci_name(pdev));
+                                dev_printk(KERN_ERR, &pdev->dev,
+                                           "64-bit DMA enable failed\n");
                                 return rc;
                         }
                 }
         } else {
                 rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
                 if (rc) {
-                        printk(KERN_ERR DRV_NAME "(%s): 32-bit DMA enable failed\n",
-                                pci_name(pdev));
+                        dev_printk(KERN_ERR, &pdev->dev,
+                                   "32-bit DMA enable failed\n");
                         return rc;
                 }
                 rc = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
                 if (rc) {
-                        printk(KERN_ERR DRV_NAME "(%s): 32-bit consistent DMA enable failed\n",
-                                pci_name(pdev));
+                        dev_printk(KERN_ERR, &pdev->dev,
+                                   "32-bit consistent DMA enable failed\n");
                         return rc;
                 }
         }
@@ -915,10 +915,10 @@ static void ahci_print_info(struct ata_probe_ent *probe_ent)
         else
                 scc_s = "unknown";
 
-        printk(KERN_INFO DRV_NAME "(%s) AHCI %02x%02x.%02x%02x "
+        dev_printk(KERN_INFO, &pdev->dev,
+                "AHCI %02x%02x.%02x%02x "
                 "%u slots %u ports %s Gbps 0x%x impl %s mode\n"
                 ,
-                pci_name(pdev),
 
                 (vers >> 24) & 0xff,
                 (vers >> 16) & 0xff,
@@ -931,11 +931,11 @@ static void ahci_print_info(struct ata_probe_ent *probe_ent)
                 impl,
                 scc_s);
 
-        printk(KERN_INFO DRV_NAME "(%s) flags: "
+        dev_printk(KERN_INFO, &pdev->dev,
+                "flags: "
                 "%s%s%s%s%s%s"
                 "%s%s%s%s%s%s%s\n"
                 ,
-                pci_name(pdev),
 
                 cap & (1 << 31) ? "64bit " : "",
                 cap & (1 << 30) ? "ncq " : "",
@@ -968,7 +968,7 @@ static int ahci_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
         VPRINTK("ENTER\n");
 
         if (!printed_version++)
-                printk(KERN_DEBUG DRV_NAME " version " DRV_VERSION "\n");
+                dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
 
         rc = pci_enable_device(pdev);
         if (rc)
diff --git a/drivers/scsi/ata_piix.c b/drivers/scsi/ata_piix.c
index be021478f416..7f8aa1b552ce 100644
--- a/drivers/scsi/ata_piix.c
+++ b/drivers/scsi/ata_piix.c
@@ -45,6 +45,7 @@
 #include <linux/init.h>
 #include <linux/blkdev.h>
 #include <linux/delay.h>
+#include <linux/device.h>
 #include "scsi.h"
 #include <scsi/scsi_host.h>
 #include <linux/libata.h>
@@ -621,18 +622,19 @@ static int piix_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
 {
         static int printed_version;
         struct ata_port_info *port_info[2];
-        unsigned int combined = 0, n_ports = 1;
+        unsigned int combined = 0;
         unsigned int pata_chan = 0, sata_chan = 0;
 
         if (!printed_version++)
-                printk(KERN_DEBUG DRV_NAME " version " DRV_VERSION "\n");
+                dev_printk(KERN_DEBUG, &pdev->dev,
+                           "version " DRV_VERSION "\n");
 
         /* no hotplugging support (FIXME) */
         if (!in_module_init)
                 return -ENODEV;
 
         port_info[0] = &piix_port_info[ent->driver_data];
-        port_info[1] = NULL;
+        port_info[1] = &piix_port_info[ent->driver_data];
 
         if (port_info[0]->host_flags & PIIX_FLAG_AHCI) {
                 u8 tmp;
@@ -670,12 +672,13 @@ static int piix_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
                 port_info[sata_chan] = &piix_port_info[ent->driver_data];
                 port_info[sata_chan]->host_flags |= ATA_FLAG_SLAVE_POSS;
                 port_info[pata_chan] = &piix_port_info[ich5_pata];
-                n_ports++;
 
-                printk(KERN_WARNING DRV_NAME ": combined mode detected\n");
+                dev_printk(KERN_WARNING, &pdev->dev,
+                           "combined mode detected (p=%u, s=%u)\n",
+                           pata_chan, sata_chan);
         }
 
-        return ata_pci_init_one(pdev, port_info, n_ports);
+        return ata_pci_init_one(pdev, port_info, 2);
 }
 
 static int __init piix_init(void)
diff --git a/drivers/scsi/libata-core.c b/drivers/scsi/libata-core.c
index 6cab14965cc8..2e022240051e 100644
--- a/drivers/scsi/libata-core.c
+++ b/drivers/scsi/libata-core.c
@@ -4621,11 +4621,11 @@ ata_pci_init_native_mode(struct pci_dev *pdev, struct ata_port_info **port, int
         return probe_ent;
 }
 
-static struct ata_probe_ent *ata_pci_init_legacy_port(struct pci_dev *pdev, struct ata_port_info **port, int port_num)
+static struct ata_probe_ent *ata_pci_init_legacy_port(struct pci_dev *pdev, struct ata_port_info *port, int port_num)
 {
         struct ata_probe_ent *probe_ent;
 
-        probe_ent = ata_probe_ent_alloc(pci_dev_to_dev(pdev), port[0]);
+        probe_ent = ata_probe_ent_alloc(pci_dev_to_dev(pdev), port);
         if (!probe_ent)
                 return NULL;
 
@@ -4772,9 +4772,9 @@ int ata_pci_init_one (struct pci_dev *pdev, struct ata_port_info **port_info,
 
         if (legacy_mode) {
                 if (legacy_mode & (1 << 0))
-                        probe_ent = ata_pci_init_legacy_port(pdev, port, 0);
+                        probe_ent = ata_pci_init_legacy_port(pdev, port[0], 0);
                 if (legacy_mode & (1 << 1))
-                        probe_ent2 = ata_pci_init_legacy_port(pdev, port, 1);
+                        probe_ent2 = ata_pci_init_legacy_port(pdev, port[1], 1);
         } else {
                 if (n_ports == 2)
                         probe_ent = ata_pci_init_native_mode(pdev, port, ATA_PORT_PRIMARY | ATA_PORT_SECONDARY);
diff --git a/drivers/scsi/pdc_adma.c b/drivers/scsi/pdc_adma.c
index 988d0d70a277..a50588c60fab 100644
--- a/drivers/scsi/pdc_adma.c
+++ b/drivers/scsi/pdc_adma.c
@@ -40,6 +40,7 @@
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/sched.h>
+#include <linux/device.h>
 #include "scsi.h"
 #include <scsi/scsi_host.h>
 #include <asm/io.h>
@@ -626,16 +627,14 @@ static int adma_set_dma_masks(struct pci_dev *pdev, void __iomem *mmio_base)
 
         rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
         if (rc) {
-                printk(KERN_ERR DRV_NAME
-                        "(%s): 32-bit DMA enable failed\n",
-                        pci_name(pdev));
+                dev_printk(KERN_ERR, &pdev->dev,
+                        "32-bit DMA enable failed\n");
                 return rc;
         }
         rc = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
         if (rc) {
-                printk(KERN_ERR DRV_NAME
-                        "(%s): 32-bit consistent DMA enable failed\n",
-                        pci_name(pdev));
+                dev_printk(KERN_ERR, &pdev->dev,
+                        "32-bit consistent DMA enable failed\n");
                 return rc;
         }
         return 0;
@@ -651,7 +650,7 @@ static int adma_ata_init_one(struct pci_dev *pdev,
         int rc, port_no;
 
         if (!printed_version++)
-                printk(KERN_DEBUG DRV_NAME " version " DRV_VERSION "\n");
+                dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
 
         rc = pci_enable_device(pdev);
         if (rc)
diff --git a/drivers/scsi/sata_mv.c b/drivers/scsi/sata_mv.c
index a3ab14c79cdd..64af334e71f4 100644
--- a/drivers/scsi/sata_mv.c
+++ b/drivers/scsi/sata_mv.c
@@ -29,6 +29,7 @@
 #include <linux/interrupt.h>
 #include <linux/sched.h>
 #include <linux/dma-mapping.h>
+#include <linux/device.h>
 #include "scsi.h"
 #include <scsi/scsi_host.h>
 #include <linux/libata.h>
@@ -1438,9 +1439,9 @@ static void mv_print_info(struct ata_probe_ent *probe_ent)
         else
                 scc_s = "unknown";
 
-        printk(KERN_INFO DRV_NAME 
-               "(%s) %u slots %u ports %s mode IRQ via %s\n",
-               pci_name(pdev), (unsigned)MV_MAX_Q_DEPTH, probe_ent->n_ports, 
+        dev_printk(KERN_INFO, &pdev->dev,
+               "%u slots %u ports %s mode IRQ via %s\n",
+               (unsigned)MV_MAX_Q_DEPTH, probe_ent->n_ports, 
                scc_s, (MV_HP_FLAG_MSI & hpriv->hp_flags) ? "MSI" : "INTx");
 }
 
@@ -1461,9 +1462,8 @@ static int mv_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
         void __iomem *mmio_base;
         int pci_dev_busy = 0, rc;
 
-        if (!printed_version++) {
-                printk(KERN_INFO DRV_NAME " version " DRV_VERSION "\n");
-        }
+        if (!printed_version++)
+                dev_printk(KERN_INFO, &pdev->dev, "version " DRV_VERSION "\n");
 
         rc = pci_enable_device(pdev);
         if (rc) {
diff --git a/drivers/scsi/sata_nv.c b/drivers/scsi/sata_nv.c
index 1a56d6c79ddd..d573888eda76 100644
--- a/drivers/scsi/sata_nv.c
+++ b/drivers/scsi/sata_nv.c
@@ -61,6 +61,7 @@
 #include <linux/blkdev.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
+#include <linux/device.h>
 #include "scsi.h"
 #include <scsi/scsi_host.h>
 #include <linux/libata.h>
@@ -383,7 +384,7 @@ static int nv_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
                         return -ENODEV;
 
         if (!printed_version++)
-                printk(KERN_DEBUG DRV_NAME " version " DRV_VERSION "\n");
+                dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
 
         rc = pci_enable_device(pdev);
         if (rc)
diff --git a/drivers/scsi/sata_promise.c b/drivers/scsi/sata_promise.c
index 8f41702275db..b41c977d6fab 100644
--- a/drivers/scsi/sata_promise.c
+++ b/drivers/scsi/sata_promise.c
@@ -38,6 +38,7 @@
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/sched.h>
+#include <linux/device.h>
 #include "scsi.h"
 #include <scsi/scsi_host.h>
 #include <linux/libata.h>
@@ -633,7 +634,7 @@ static int pdc_ata_init_one (struct pci_dev *pdev, const struct pci_device_id *e
         int rc;
 
         if (!printed_version++)
-                printk(KERN_DEBUG DRV_NAME " version " DRV_VERSION "\n");
+                dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
 
         /*
          * If this driver happens to only be useful on Apple's K2, then
diff --git a/drivers/scsi/sata_qstor.c b/drivers/scsi/sata_qstor.c
index 8c20229b01b4..65502c157a54 100644
--- a/drivers/scsi/sata_qstor.c
+++ b/drivers/scsi/sata_qstor.c
@@ -35,6 +35,7 @@
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/sched.h>
+#include <linux/device.h>
 #include "scsi.h"
 #include <scsi/scsi_host.h>
 #include <asm/io.h>
@@ -602,25 +603,22 @@ static int qs_set_dma_masks(struct pci_dev *pdev, void __iomem *mmio_base)
                 if (rc) {
                         rc = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
                         if (rc) {
-                                printk(KERN_ERR DRV_NAME
-                                        "(%s): 64-bit DMA enable failed\n",
-                                        pci_name(pdev));
+                                dev_printk(KERN_ERR, &pdev->dev,
+                                           "64-bit DMA enable failed\n");
                                 return rc;
                         }
                 }
         } else {
                 rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
                 if (rc) {
-                        printk(KERN_ERR DRV_NAME
-                                "(%s): 32-bit DMA enable failed\n",
-                                pci_name(pdev));
+                        dev_printk(KERN_ERR, &pdev->dev,
+                                "32-bit DMA enable failed\n");
                         return rc;
                 }
                 rc = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
                 if (rc) {
-                        printk(KERN_ERR DRV_NAME
-                                "(%s): 32-bit consistent DMA enable failed\n",
-                                pci_name(pdev));
+                        dev_printk(KERN_ERR, &pdev->dev,
+                                "32-bit consistent DMA enable failed\n");
                         return rc;
                 }
         }
@@ -637,7 +635,7 @@ static int qs_ata_init_one(struct pci_dev *pdev,
         int rc, port_no;
 
         if (!printed_version++)
-                printk(KERN_DEBUG DRV_NAME " version " DRV_VERSION "\n");
+                dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
 
         rc = pci_enable_device(pdev);
         if (rc)
diff --git a/drivers/scsi/sata_sil.c b/drivers/scsi/sata_sil.c
index 3a056173fb95..435f7e0085ec 100644
--- a/drivers/scsi/sata_sil.c
+++ b/drivers/scsi/sata_sil.c
@@ -41,6 +41,7 @@
 #include <linux/blkdev.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
+#include <linux/device.h>
 #include "scsi.h"
 #include <scsi/scsi_host.h>
 #include <linux/libata.h>
@@ -386,7 +387,7 @@ static int sil_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
         u8 cls;
 
         if (!printed_version++)
-                printk(KERN_DEBUG DRV_NAME " version " DRV_VERSION "\n");
+                dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
 
         /*
          * If this driver happens to only be useful on Apple's K2, then
@@ -463,8 +464,8 @@ static int sil_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
                         writeb(cls, mmio_base + SIL_FIFO_W3);
                 }
         } else
-                printk(KERN_WARNING DRV_NAME "(%s): cache line size not set.  Driver may not function\n",
-                        pci_name(pdev));
+                dev_printk(KERN_WARNING, &pdev->dev,
+                         "cache line size not set.  Driver may not function\n");
 
         if (ent->driver_data == sil_3114) {
                 irq_mask = SIL_MASK_4PORT;
diff --git a/drivers/scsi/sata_sil24.c b/drivers/scsi/sata_sil24.c
index 05ce84286aea..211ec7eebc9c 100644
--- a/drivers/scsi/sata_sil24.c
+++ b/drivers/scsi/sata_sil24.c
@@ -35,6 +35,7 @@
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/dma-mapping.h>
+#include <linux/device.h>
 #include <scsi/scsi_host.h>
 #include "scsi.h"
 #include <linux/libata.h>
@@ -695,7 +696,7 @@ static int sil24_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
         int i, rc;
 
         if (!printed_version++)
-                printk(KERN_DEBUG DRV_NAME " version " DRV_VERSION "\n");
+                dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
 
         rc = pci_enable_device(pdev);
         if (rc)
@@ -755,14 +756,14 @@ static int sil24_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
          */
         rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
         if (rc) {
-                printk(KERN_ERR DRV_NAME "(%s): 32-bit DMA enable failed\n",
-                       pci_name(pdev));
+                dev_printk(KERN_ERR, &pdev->dev,
+                           "32-bit DMA enable failed\n");
                 goto out_free;
         }
         rc = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
         if (rc) {
-                printk(KERN_ERR DRV_NAME "(%s): 32-bit consistent DMA enable failed\n",
-                       pci_name(pdev));
+                dev_printk(KERN_ERR, &pdev->dev,
+                           "32-bit consistent DMA enable failed\n");
                 goto out_free;
         }
 
@@ -798,9 +799,8 @@ static int sil24_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
                                         break;
                         }
                         if (tmp & PORT_CS_PORT_RST)
-                                printk(KERN_ERR DRV_NAME
-                                       "(%s): failed to clear port RST\n",
-                                       pci_name(pdev));
+                                dev_printk(KERN_ERR, &pdev->dev,
+                                           "failed to clear port RST\n");
                 }
 
                 /* Zero error counters. */
@@ -829,9 +829,8 @@ static int sil24_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
 
                 /* Reset itself */
                 if (__sil24_reset_controller(port))
-                        printk(KERN_ERR DRV_NAME
-                               "(%s): failed to reset controller\n",
-                               pci_name(pdev));
+                        dev_printk(KERN_ERR, &pdev->dev,
+                                   "failed to reset controller\n");
         }
 
         /* Turn on interrupts */
diff --git a/drivers/scsi/sata_sis.c b/drivers/scsi/sata_sis.c
index 057f7b98b6c4..42288be0e561 100644
--- a/drivers/scsi/sata_sis.c
+++ b/drivers/scsi/sata_sis.c
@@ -38,6 +38,7 @@
 #include <linux/blkdev.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
+#include <linux/device.h>
 #include "scsi.h"
 #include <scsi/scsi_host.h>
 #include <linux/libata.h>
@@ -237,6 +238,7 @@ static void sis_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val)
 
 static int sis_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
 {
+        static int printed_version;
         struct ata_probe_ent *probe_ent = NULL;
         int rc;
         u32 genctl;
@@ -245,6 +247,9 @@ static int sis_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
         u8 pmr;
         u8 port2_start;
 
+        if (!printed_version++)
+                dev_printk(KERN_INFO, &pdev->dev, "version " DRV_VERSION "\n");
+
         rc = pci_enable_device(pdev);
         if (rc)
                 return rc;
@@ -288,16 +293,18 @@ static int sis_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
         pci_read_config_byte(pdev, SIS_PMR, &pmr);
         if (ent->device != 0x182) {
                 if ((pmr & SIS_PMR_COMBINED) == 0) {
-                        printk(KERN_INFO "sata_sis: Detected SiS 180/181 chipset in SATA mode\n");
+                        dev_printk(KERN_INFO, &pdev->dev,
+                                   "Detected SiS 180/181 chipset in SATA mode\n");
                         port2_start = 64;
                 }
                 else {
-                        printk(KERN_INFO "sata_sis: Detected SiS 180/181 chipset in combined mode\n");
+                        dev_printk(KERN_INFO, &pdev->dev,
+                                   "Detected SiS 180/181 chipset in combined mode\n");
                         port2_start=0;
                 }
         }
         else {
-                printk(KERN_INFO "sata_sis: Detected SiS 182 chipset\n");
+                dev_printk(KERN_INFO, &pdev->dev, "Detected SiS 182 chipset\n");
                 port2_start = 0x20;
         }
 
diff --git a/drivers/scsi/sata_svw.c b/drivers/scsi/sata_svw.c
index 46208f52d0e1..db615ff794d8 100644
--- a/drivers/scsi/sata_svw.c
+++ b/drivers/scsi/sata_svw.c
@@ -44,6 +44,7 @@
 #include <linux/blkdev.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
+#include <linux/device.h>
 #include "scsi.h"
 #include <scsi/scsi_host.h>
 #include <linux/libata.h>
@@ -362,7 +363,7 @@ static int k2_sata_init_one (struct pci_dev *pdev, const struct pci_device_id *e
         int i;
 
         if (!printed_version++)
-                printk(KERN_DEBUG DRV_NAME " version " DRV_VERSION "\n");
+                dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
 
         /*
          * If this driver happens to only be useful on Apple's K2, then
diff --git a/drivers/scsi/sata_sx4.c b/drivers/scsi/sata_sx4.c
index 8e2e7b8308c0..f859bbd681ed 100644
--- a/drivers/scsi/sata_sx4.c
+++ b/drivers/scsi/sata_sx4.c
@@ -38,6 +38,7 @@
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/sched.h>
+#include <linux/device.h>
 #include "scsi.h"
 #include <scsi/scsi_host.h>
 #include <linux/libata.h>
@@ -1384,7 +1385,7 @@ static int pdc_sata_init_one (struct pci_dev *pdev, const struct pci_device_id *
         int rc;
 
         if (!printed_version++)
-                printk(KERN_DEBUG DRV_NAME " version " DRV_VERSION "\n");
+                dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
 
         /*
          * If this driver happens to only be useful on Apple's K2, then
diff --git a/drivers/scsi/sata_uli.c b/drivers/scsi/sata_uli.c
index d68dc7d3422c..a5e245c098e1 100644
--- a/drivers/scsi/sata_uli.c
+++ b/drivers/scsi/sata_uli.c
@@ -32,6 +32,7 @@
 #include <linux/blkdev.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
+#include <linux/device.h>
 #include "scsi.h"
 #include <scsi/scsi_host.h>
 #include <linux/libata.h>
@@ -178,12 +179,16 @@ static void uli_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val)
 
 static int uli_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
 {
+        static int printed_version;
         struct ata_probe_ent *probe_ent;
         struct ata_port_info *ppi;
         int rc;
         unsigned int board_idx = (unsigned int) ent->driver_data;
         int pci_dev_busy = 0;
 
+        if (!printed_version++)
+                dev_printk(KERN_INFO, &pdev->dev, "version " DRV_VERSION "\n");
+
         rc = pci_enable_device(pdev);
         if (rc)
                 return rc;
diff --git a/drivers/scsi/sata_via.c b/drivers/scsi/sata_via.c
index 80e291a909a9..b3ecdbe400e9 100644
--- a/drivers/scsi/sata_via.c
+++ b/drivers/scsi/sata_via.c
@@ -41,6 +41,7 @@
 #include <linux/init.h>
 #include <linux/blkdev.h>
 #include <linux/delay.h>
+#include <linux/device.h>
 #include "scsi.h"
 #include <scsi/scsi_host.h>
 #include <linux/libata.h>
@@ -259,15 +260,15 @@ static void svia_configure(struct pci_dev *pdev)
         u8 tmp8;
 
         pci_read_config_byte(pdev, PCI_INTERRUPT_LINE, &tmp8);
-        printk(KERN_INFO DRV_NAME "(%s): routed to hard irq line %d\n",
-               pci_name(pdev),
+        dev_printk(KERN_INFO, &pdev->dev, "routed to hard irq line %d\n",
                (int) (tmp8 & 0xf0) == 0xf0 ? 0 : tmp8 & 0x0f);
 
         /* make sure SATA channels are enabled */
         pci_read_config_byte(pdev, SATA_CHAN_ENAB, &tmp8);
         if ((tmp8 & ALL_PORTS) != ALL_PORTS) {
-                printk(KERN_DEBUG DRV_NAME "(%s): enabling SATA channels (0x%x)\n",
-                       pci_name(pdev), (int) tmp8);
+                dev_printk(KERN_DEBUG, &pdev->dev,
+                           "enabling SATA channels (0x%x)\n",
+                           (int) tmp8);
                 tmp8 |= ALL_PORTS;
                 pci_write_config_byte(pdev, SATA_CHAN_ENAB, tmp8);
         }
@@ -275,8 +276,9 @@ static void svia_configure(struct pci_dev *pdev)
         /* make sure interrupts for each channel sent to us */
         pci_read_config_byte(pdev, SATA_INT_GATE, &tmp8);
         if ((tmp8 & ALL_PORTS) != ALL_PORTS) {
-                printk(KERN_DEBUG DRV_NAME "(%s): enabling SATA channel interrupts (0x%x)\n",
-                       pci_name(pdev), (int) tmp8);
+                dev_printk(KERN_DEBUG, &pdev->dev,
+                           "enabling SATA channel interrupts (0x%x)\n",
+                           (int) tmp8);
                 tmp8 |= ALL_PORTS;
                 pci_write_config_byte(pdev, SATA_INT_GATE, tmp8);
         }
@@ -284,8 +286,9 @@ static void svia_configure(struct pci_dev *pdev)
         /* make sure native mode is enabled */
         pci_read_config_byte(pdev, SATA_NATIVE_MODE, &tmp8);
         if ((tmp8 & NATIVE_MODE_ALL) != NATIVE_MODE_ALL) {
-                printk(KERN_DEBUG DRV_NAME "(%s): enabling SATA channel native mode (0x%x)\n",
-                       pci_name(pdev), (int) tmp8);
+                dev_printk(KERN_DEBUG, &pdev->dev,
+                           "enabling SATA channel native mode (0x%x)\n",
+                           (int) tmp8);
                 tmp8 |= NATIVE_MODE_ALL;
                 pci_write_config_byte(pdev, SATA_NATIVE_MODE, tmp8);
         }
@@ -303,7 +306,7 @@ static int svia_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
         u8 tmp8;
 
         if (!printed_version++)
-                printk(KERN_DEBUG DRV_NAME " version " DRV_VERSION "\n");
+                dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
 
         rc = pci_enable_device(pdev);
         if (rc)
@@ -318,8 +321,9 @@ static int svia_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
         if (board_id == vt6420) {
                 pci_read_config_byte(pdev, SATA_PATA_SHARING, &tmp8);
                 if (tmp8 & SATA_2DEV) {
-                        printk(KERN_ERR DRV_NAME "(%s): SATA master/slave not supported (0x%x)\n",
-                        pci_name(pdev), (int) tmp8);
+                        dev_printk(KERN_ERR, &pdev->dev,
+                                   "SATA master/slave not supported (0x%x)\n",
+                                   (int) tmp8);
                         rc = -EIO;
                         goto err_out_regions;
                 }
@@ -332,10 +336,11 @@ static int svia_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
         for (i = 0; i < ARRAY_SIZE(svia_bar_sizes); i++)
                 if ((pci_resource_start(pdev, i) == 0) ||
                     (pci_resource_len(pdev, i) < bar_sizes[i])) {
-                        printk(KERN_ERR DRV_NAME "(%s): invalid PCI BAR %u (sz 0x%lx, val 0x%lx)\n",
-                               pci_name(pdev), i,
-                               pci_resource_start(pdev, i),
-                               pci_resource_len(pdev, i));
+                        dev_printk(KERN_ERR, &pdev->dev,
+                                   "invalid PCI BAR %u (sz 0x%lx, val 0x%lx)\n",
+                                   i,
+                                   pci_resource_start(pdev, i),
+                                   pci_resource_len(pdev, i));
                         rc = -ENODEV;
                         goto err_out_regions;
                 }
@@ -353,8 +358,7 @@ static int svia_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
                 probe_ent = vt6421_init_probe_ent(pdev);
 
         if (!probe_ent) {
-                printk(KERN_ERR DRV_NAME "(%s): out of memory\n",
-                       pci_name(pdev));
+                dev_printk(KERN_ERR, &pdev->dev, "out of memory\n");
                 rc = -ENOMEM;
                 goto err_out_regions;
         }
diff --git a/drivers/scsi/sata_vsc.c b/drivers/scsi/sata_vsc.c
index 54273e0063c7..bb84ba0c7e83 100644
--- a/drivers/scsi/sata_vsc.c
+++ b/drivers/scsi/sata_vsc.c
@@ -42,6 +42,7 @@
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/dma-mapping.h>
+#include <linux/device.h>
 #include "scsi.h"
 #include <scsi/scsi_host.h>
 #include <linux/libata.h>
@@ -295,7 +296,7 @@ static int __devinit vsc_sata_init_one (struct pci_dev *pdev, const struct pci_d
         int rc;
 
         if (!printed_version++)
-                printk(KERN_DEBUG DRV_NAME " version " DRV_VERSION "\n");
+                dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
 
         rc = pci_enable_device(pdev);
         if (rc)
diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index f2781ca42761..fc0f12ba89cc 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -1274,14 +1274,12 @@ static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fat
         }
 
         if ((fattr->valid & NFS_ATTR_FATTR) == 0) {
-                spin_unlock(&inode->i_lock);
                 return 0;
         }
 
         /* Has the inode gone and changed behind our back? */
         if (nfsi->fileid != fattr->fileid
                         || (inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT)) {
-                spin_unlock(&inode->i_lock);
                 return -EIO;
         }