Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc-next-2.6

* git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc-next-2.6: (180 commits)
  leo: disable cursor when leaving graphics mode
  cg6: disable cursor when leaving graphics mode
  sparc32: sun4m interrupt mask cleanup
  drivers/rtc/Kconfig: don't build rtc-cmos.o on sparc32
  sparc: arch/sparc/kernel/pmc.c -- extra #include?
  sparc32: Add more extensive documentation of sun4m interrupts.
  sparc32: Kill irq_rcvreg from sun4m_irq.c
  sparc32: Delete master_l10_limit.
  sparc32: Use PROM device probing for sun4c timers.
  sparc32: Use PROM device probing for sun4c interrupt register.
  sparc32: Delete claim_ticker14().
  sparc32: Stop calling claim_ticker14() from sun4c_irq.c
  sparc32: Kill clear_profile_irq btfixup entry.
  sparc32: Call sun4m_clear_profile_irq() directly from sun4m_smp.c
  sparc32: Remove #if 0'd code from sun4c_irq.c
  sparc32: Remove some SMP ifdefs in sun4d_irq.c
  sparc32: Use PROM infrastructure for probing and mapping sun4d timers.
  sparc32: Use PROM device probing for sun4m irq registers.
  sparc32: Use PROM device probing for sun4m timer registers.
  sparc: Fix user_regset 'n' field values.
  ...

4 files changed, 222 insertions, 196 deletions

diff --git a/drivers/scsi/esp_scsi.h b/drivers/scsi/esp_scsi.h
index bb43a1388188..28e22acf87ea 100644
--- a/drivers/scsi/esp_scsi.h
+++ b/drivers/scsi/esp_scsi.h
@@ -521,7 +521,8 @@ struct esp {
 
         struct completion       *eh_reset;
 
-        struct sbus_dma         *dma;
+        void                    *dma;
+        int                     dmarev;
 };
 
 /* A front-end driver for the ESP chip should do the following in
diff --git a/drivers/scsi/qlogicpti.c b/drivers/scsi/qlogicpti.c
index 905350896725..69d6ad862b60 100644
--- a/drivers/scsi/qlogicpti.c
+++ b/drivers/scsi/qlogicpti.c
@@ -1,6 +1,6 @@
 /* qlogicpti.c: Performance Technologies QlogicISP sbus card driver.
  *
- * Copyright (C) 1996, 2006 David S. Miller (davem@davemloft.net)
+ * Copyright (C) 1996, 2006, 2008 David S. Miller (davem@davemloft.net)
  *
  * A lot of this driver was directly stolen from Erik H. Moe's PCI
  * Qlogic ISP driver.  Mucho kudos to him for this code.
@@ -25,12 +25,14 @@
 #include <linux/interrupt.h>
 #include <linux/module.h>
 #include <linux/jiffies.h>
+#include <linux/dma-mapping.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
 
 #include <asm/byteorder.h>
 
 #include "qlogicpti.h"
 
-#include <asm/sbus.h>
 #include <asm/dma.h>
 #include <asm/system.h>
 #include <asm/ptrace.h>
@@ -157,7 +159,7 @@ static inline void set_sbus_cfg1(struct qlogicpti *qpti)
          * is a nop and the chip ends up using the smallest burst
          * size. -DaveM
          */
-        if (sbus_can_burst64(qpti->sdev) && (bursts & DMA_BURST64)) {
+        if (sbus_can_burst64() && (bursts & DMA_BURST64)) {
                 val = (SBUS_CFG1_BENAB | SBUS_CFG1_B64);
         } else
 #endif
@@ -684,19 +686,19 @@ static void __devexit qpti_chain_del(struct qlogicpti *qpti)
 
 static int __devinit qpti_map_regs(struct qlogicpti *qpti)
 {
-        struct sbus_dev *sdev = qpti->sdev;
+        struct of_device *op = qpti->op;
 
-        qpti->qregs = sbus_ioremap(&sdev->resource[0], 0,
-                                   sdev->reg_addrs[0].reg_size,
-                                   "PTI Qlogic/ISP");
+        qpti->qregs = of_ioremap(&op->resource[0], 0,
+                                 resource_size(&op->resource[0]),
+                                 "PTI Qlogic/ISP");
         if (!qpti->qregs) {
                 printk("PTI: Qlogic/ISP registers are unmappable\n");
                 return -1;
         }
         if (qpti->is_pti) {
-                qpti->sreg = sbus_ioremap(&sdev->resource[0], (16 * 4096),
-                                          sizeof(unsigned char),
-                                          "PTI Qlogic/ISP statreg");
+                qpti->sreg = of_ioremap(&op->resource[0], (16 * 4096),
+                                        sizeof(unsigned char),
+                                        "PTI Qlogic/ISP statreg");
                 if (!qpti->sreg) {
                         printk("PTI: Qlogic/ISP status register is unmappable\n");
                         return -1;
@@ -707,9 +709,9 @@ static int __devinit qpti_map_regs(struct qlogicpti *qpti)
 
 static int __devinit qpti_register_irq(struct qlogicpti *qpti)
 {
-        struct sbus_dev *sdev = qpti->sdev;
+        struct of_device *op = qpti->op;
 
-        qpti->qhost->irq = qpti->irq = sdev->irqs[0];
+        qpti->qhost->irq = qpti->irq = op->irqs[0];
 
         /* We used to try various overly-clever things to
          * reduce the interrupt processing overhead on
@@ -732,17 +734,19 @@ fail:
 
 static void __devinit qpti_get_scsi_id(struct qlogicpti *qpti)
 {
-        qpti->scsi_id = prom_getintdefault(qpti->prom_node,
-                                           "initiator-id",
-                                           -1);
+        struct of_device *op = qpti->op;
+        struct device_node *dp;
+
+        dp = op->node;
+
+        qpti->scsi_id = of_getintprop_default(dp, "initiator-id", -1);
         if (qpti->scsi_id == -1)
-                qpti->scsi_id = prom_getintdefault(qpti->prom_node,
-                                                   "scsi-initiator-id",
-                                                   -1);
+                qpti->scsi_id = of_getintprop_default(dp, "scsi-initiator-id",
+                                                      -1);
         if (qpti->scsi_id == -1)
                 qpti->scsi_id =
-                        prom_getintdefault(qpti->sdev->bus->prom_node,
-                                           "scsi-initiator-id", 7);
+                        of_getintprop_default(dp->parent,
+                                              "scsi-initiator-id", 7);
         qpti->qhost->this_id = qpti->scsi_id;
         qpti->qhost->max_sectors = 64;
 
@@ -751,12 +755,11 @@ static void __devinit qpti_get_scsi_id(struct qlogicpti *qpti)
 
 static void qpti_get_bursts(struct qlogicpti *qpti)
 {
-        struct sbus_dev *sdev = qpti->sdev;
+        struct of_device *op = qpti->op;
         u8 bursts, bmask;
 
-        bursts = prom_getintdefault(qpti->prom_node, "burst-sizes", 0xff);
-        bmask = prom_getintdefault(sdev->bus->prom_node,
-                                   "burst-sizes", 0xff);
+        bursts = of_getintprop_default(op->node, "burst-sizes", 0xff);
+        bmask = of_getintprop_default(op->node->parent, "burst-sizes", 0xff);
         if (bmask != 0xff)
                 bursts &= bmask;
         if (bursts == 0xff ||
@@ -785,25 +788,25 @@ static void qpti_get_clock(struct qlogicpti *qpti)
  */
 static int __devinit qpti_map_queues(struct qlogicpti *qpti)
 {
-        struct sbus_dev *sdev = qpti->sdev;
+        struct of_device *op = qpti->op;
 
 #define QSIZE(entries)  (((entries) + 1) * QUEUE_ENTRY_LEN)
-        qpti->res_cpu = sbus_alloc_consistent(sdev,
-                                              QSIZE(RES_QUEUE_LEN),
-                                              &qpti->res_dvma);
+        qpti->res_cpu = dma_alloc_coherent(&op->dev,
+                                           QSIZE(RES_QUEUE_LEN),
+                                           &qpti->res_dvma, GFP_ATOMIC);
         if (qpti->res_cpu == NULL ||
             qpti->res_dvma == 0) {
                 printk("QPTI: Cannot map response queue.\n");
                 return -1;
         }
 
-        qpti->req_cpu = sbus_alloc_consistent(sdev,
-                                              QSIZE(QLOGICPTI_REQ_QUEUE_LEN),
-                                              &qpti->req_dvma);
+        qpti->req_cpu = dma_alloc_coherent(&op->dev,
+                                           QSIZE(QLOGICPTI_REQ_QUEUE_LEN),
+                                           &qpti->req_dvma, GFP_ATOMIC);
         if (qpti->req_cpu == NULL ||
             qpti->req_dvma == 0) {
-                sbus_free_consistent(sdev, QSIZE(RES_QUEUE_LEN),
-                                     qpti->res_cpu, qpti->res_dvma);
+                dma_free_coherent(&op->dev, QSIZE(RES_QUEUE_LEN),
+                                  qpti->res_cpu, qpti->res_dvma);
                 printk("QPTI: Cannot map request queue.\n");
                 return -1;
         }
@@ -875,8 +878,9 @@ static inline int load_cmd(struct scsi_cmnd *Cmnd, struct Command_Entry *cmd,
                 int sg_count;
 
                 sg = scsi_sglist(Cmnd);
-                sg_count = sbus_map_sg(qpti->sdev, sg, scsi_sg_count(Cmnd),
-                                                      Cmnd->sc_data_direction);
+                sg_count = dma_map_sg(&qpti->op->dev, sg,
+                                      scsi_sg_count(Cmnd),
+                                      Cmnd->sc_data_direction);
 
                 ds = cmd->dataseg;
                 cmd->segment_cnt = sg_count;
@@ -1152,9 +1156,9 @@ static struct scsi_cmnd *qlogicpti_intr_handler(struct qlogicpti *qpti)
                         Cmnd->result = DID_ERROR << 16;
 
                 if (scsi_bufflen(Cmnd))
-                        sbus_unmap_sg(qpti->sdev,
-                                      scsi_sglist(Cmnd), scsi_sg_count(Cmnd),
-                                      Cmnd->sc_data_direction);
+                        dma_unmap_sg(&qpti->op->dev,
+                                     scsi_sglist(Cmnd), scsi_sg_count(Cmnd),
+                                     Cmnd->sc_data_direction);
 
                 qpti->cmd_count[Cmnd->device->id]--;
                 sbus_writew(out_ptr, qpti->qregs + MBOX5);
@@ -1268,34 +1272,32 @@ static struct scsi_host_template qpti_template = {
         .use_clustering         = ENABLE_CLUSTERING,
 };
 
-static int __devinit qpti_sbus_probe(struct of_device *dev, const struct of_device_id *match)
+static int __devinit qpti_sbus_probe(struct of_device *op, const struct of_device_id *match)
 {
-        static int nqptis;
-        struct sbus_dev *sdev = to_sbus_device(&dev->dev);
-        struct device_node *dp = dev->node;
         struct scsi_host_template *tpnt = match->data;
+        struct device_node *dp = op->node;
         struct Scsi_Host *host;
         struct qlogicpti *qpti;
+        static int nqptis;
         const char *fcode;
 
         /* Sometimes Antares cards come up not completely
          * setup, and we get a report of a zero IRQ.
          */
-        if (sdev->irqs[0] == 0)
+        if (op->irqs[0] == 0)
                 return -ENODEV;
 
         host = scsi_host_alloc(tpnt, sizeof(struct qlogicpti));
         if (!host)
                 return -ENOMEM;
 
-        qpti = (struct qlogicpti *) host->hostdata;
+        qpti = shost_priv(host);
 
         host->max_id = MAX_TARGETS;
         qpti->qhost = host;
-        qpti->sdev = sdev;
+        qpti->op = op;
         qpti->qpti_id = nqptis;
-        qpti->prom_node = sdev->prom_node;
-        strcpy(qpti->prom_name, sdev->ofdev.node->name);
+        strcpy(qpti->prom_name, op->node->name);
         qpti->is_pti = strcmp(qpti->prom_name, "QLGC,isp");
 
         if (qpti_map_regs(qpti) < 0)
@@ -1341,12 +1343,12 @@ static int __devinit qpti_sbus_probe(struct of_device *dev, const struct of_devi
                 (qpti->ultra ? "Ultra" : "Fast"),
                 (qpti->differential ? "differential" : "single ended"));
 
-        if (scsi_add_host(host, &dev->dev)) {
+        if (scsi_add_host(host, &op->dev)) {
                 printk("qlogicpti%d: Failed scsi_add_host\n", qpti->qpti_id);
                 goto fail_unmap_queues;
         }
 
-        dev_set_drvdata(&sdev->ofdev.dev, qpti);
+        dev_set_drvdata(&op->dev, qpti);
 
         qpti_chain_add(qpti);
 
@@ -1357,19 +1359,20 @@ static int __devinit qpti_sbus_probe(struct of_device *dev, const struct of_devi
 
 fail_unmap_queues:
 #define QSIZE(entries)  (((entries) + 1) * QUEUE_ENTRY_LEN)
-        sbus_free_consistent(qpti->sdev,
-                             QSIZE(RES_QUEUE_LEN),
-                             qpti->res_cpu, qpti->res_dvma);
-        sbus_free_consistent(qpti->sdev,
-                             QSIZE(QLOGICPTI_REQ_QUEUE_LEN),
-                             qpti->req_cpu, qpti->req_dvma);
+        dma_free_coherent(&op->dev,
+                          QSIZE(RES_QUEUE_LEN),
+                          qpti->res_cpu, qpti->res_dvma);
+        dma_free_coherent(&op->dev,
+                          QSIZE(QLOGICPTI_REQ_QUEUE_LEN),
+                          qpti->req_cpu, qpti->req_dvma);
 #undef QSIZE
 
 fail_unmap_regs:
-        sbus_iounmap(qpti->qregs,
-                     qpti->sdev->reg_addrs[0].reg_size);
+        of_iounmap(&op->resource[0], qpti->qregs,
+                   resource_size(&op->resource[0]));
         if (qpti->is_pti)
-                sbus_iounmap(qpti->sreg, sizeof(unsigned char));
+                of_iounmap(&op->resource[0], qpti->sreg,
+                           sizeof(unsigned char));
 
 fail_free_irq:
         free_irq(qpti->irq, qpti);
@@ -1380,9 +1383,9 @@ fail_unlink:
         return -ENODEV;
 }
 
-static int __devexit qpti_sbus_remove(struct of_device *dev)
+static int __devexit qpti_sbus_remove(struct of_device *op)
 {
-        struct qlogicpti *qpti = dev_get_drvdata(&dev->dev);
+        struct qlogicpti *qpti = dev_get_drvdata(&op->dev);
 
         qpti_chain_del(qpti);
 
@@ -1395,24 +1398,25 @@ static int __devexit qpti_sbus_remove(struct of_device *dev)
         free_irq(qpti->irq, qpti);
 
 #define QSIZE(entries)  (((entries) + 1) * QUEUE_ENTRY_LEN)
-        sbus_free_consistent(qpti->sdev,
-                             QSIZE(RES_QUEUE_LEN),
-                             qpti->res_cpu, qpti->res_dvma);
-        sbus_free_consistent(qpti->sdev,
-                             QSIZE(QLOGICPTI_REQ_QUEUE_LEN),
-                             qpti->req_cpu, qpti->req_dvma);
+        dma_free_coherent(&op->dev,
+                          QSIZE(RES_QUEUE_LEN),
+                          qpti->res_cpu, qpti->res_dvma);
+        dma_free_coherent(&op->dev,
+                          QSIZE(QLOGICPTI_REQ_QUEUE_LEN),
+                          qpti->req_cpu, qpti->req_dvma);
 #undef QSIZE
 
-        sbus_iounmap(qpti->qregs, qpti->sdev->reg_addrs[0].reg_size);
+        of_iounmap(&op->resource[0], qpti->qregs,
+                   resource_size(&op->resource[0]));
         if (qpti->is_pti)
-                sbus_iounmap(qpti->sreg, sizeof(unsigned char));
+                of_iounmap(&op->resource[0], qpti->sreg, sizeof(unsigned char));
 
         scsi_host_put(qpti->qhost);
 
         return 0;
 }
 
-static struct of_device_id qpti_match[] = {
+static const struct of_device_id qpti_match[] = {
         {
                 .name = "ptisp",
                 .data = &qpti_template,
@@ -1442,7 +1446,7 @@ static struct of_platform_driver qpti_sbus_driver = {
 
 static int __init qpti_init(void)
 {
-        return of_register_driver(&qpti_sbus_driver, &sbus_bus_type);
+        return of_register_driver(&qpti_sbus_driver, &of_bus_type);
 }
 
 static void __exit qpti_exit(void)
@@ -1453,7 +1457,7 @@ static void __exit qpti_exit(void)
 MODULE_DESCRIPTION("QlogicISP SBUS driver");
 MODULE_AUTHOR("David S. Miller (davem@davemloft.net)");
 MODULE_LICENSE("GPL");
-MODULE_VERSION("2.0");
+MODULE_VERSION("2.1");
 
 module_init(qpti_init);
 module_exit(qpti_exit);
diff --git a/drivers/scsi/qlogicpti.h b/drivers/scsi/qlogicpti.h
index ef6da2df584b..9c053bbaa877 100644
--- a/drivers/scsi/qlogicpti.h
+++ b/drivers/scsi/qlogicpti.h
@@ -342,7 +342,7 @@ struct qlogicpti {
         u_int                     req_in_ptr;           /* index of next request slot */
         u_int                     res_out_ptr;          /* index of next result slot  */
         long                      send_marker;          /* must we send a marker?     */
-        struct sbus_dev          *sdev;
+        struct of_device         *op;
         unsigned long             __pad;
 
         int                       cmd_count[MAX_TARGETS];
diff --git a/drivers/scsi/sun_esp.c b/drivers/scsi/sun_esp.c
index f9cf70151366..3d73aad4bc82 100644
--- a/drivers/scsi/sun_esp.c
+++ b/drivers/scsi/sun_esp.c
@@ -1,6 +1,6 @@
 /* sun_esp.c: ESP front-end for Sparc SBUS systems.
  *
- * Copyright (C) 2007 David S. Miller (davem@davemloft.net)
+ * Copyright (C) 2007, 2008 David S. Miller (davem@davemloft.net)
  */
 
 #include <linux/kernel.h>
@@ -9,60 +9,70 @@
 #include <linux/module.h>
 #include <linux/mm.h>
 #include <linux/init.h>
+#include <linux/dma-mapping.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
 
 #include <asm/irq.h>
 #include <asm/io.h>
 #include <asm/dma.h>
 
-#include <asm/sbus.h>
-
 #include <scsi/scsi_host.h>
 
 #include "esp_scsi.h"
 
 #define DRV_MODULE_NAME         "sun_esp"
 #define PFX DRV_MODULE_NAME     ": "
-#define DRV_VERSION             "1.000"
-#define DRV_MODULE_RELDATE      "April 19, 2007"
+#define DRV_VERSION             "1.100"
+#define DRV_MODULE_RELDATE      "August 27, 2008"
 
 #define dma_read32(REG) \
         sbus_readl(esp->dma_regs + (REG))
 #define dma_write32(VAL, REG) \
         sbus_writel((VAL), esp->dma_regs + (REG))
 
-static int __devinit esp_sbus_find_dma(struct esp *esp, struct sbus_dev *dma_sdev)
-{
-        struct sbus_dev *sdev = esp->dev;
-        struct sbus_dma *dma;
+/* DVMA chip revisions */
+enum dvma_rev {
+        dvmarev0,
+        dvmaesc1,
+        dvmarev1,
+        dvmarev2,
+        dvmarev3,
+        dvmarevplus,
+        dvmahme
+};
 
-        if (dma_sdev != NULL) {
-                for_each_dvma(dma) {
-                        if (dma->sdev == dma_sdev)
-                                break;
-                }
-        } else {
-                for_each_dvma(dma) {
-                        if (dma->sdev == NULL)
-                                break;
+static int __devinit esp_sbus_setup_dma(struct esp *esp,
+                                        struct of_device *dma_of)
+{
+        esp->dma = dma_of;
 
-                        /* If bus + slot are the same and it has the
-                         * correct OBP name, it's ours.
-                         */
-                        if (sdev->bus == dma->sdev->bus &&
-                            sdev->slot == dma->sdev->slot &&
-                            (!strcmp(dma->sdev->prom_name, "dma") ||
-                             !strcmp(dma->sdev->prom_name, "espdma")))
-                                break;
-                }
-        }
+        esp->dma_regs = of_ioremap(&dma_of->resource[0], 0,
+                                   resource_size(&dma_of->resource[0]),
+                                   "espdma");
+        if (!esp->dma_regs)
+                return -ENOMEM;
 
-        if (dma == NULL) {
-                printk(KERN_ERR PFX "[%s] Cannot find dma.\n",
-                       sdev->ofdev.node->full_name);
-                return -ENODEV;
+        switch (dma_read32(DMA_CSR) & DMA_DEVICE_ID) {
+        case DMA_VERS0:
+                esp->dmarev = dvmarev0;
+                break;
+        case DMA_ESCV1:
+                esp->dmarev = dvmaesc1;
+                break;
+        case DMA_VERS1:
+                esp->dmarev = dvmarev1;
+                break;
+        case DMA_VERS2:
+                esp->dmarev = dvmarev2;
+                break;
+        case DMA_VERHME:
+                esp->dmarev = dvmahme;
+                break;
+        case DMA_VERSPLUS:
+                esp->dmarev = dvmarevplus;
+                break;
         }
-        esp->dma = dma;
-        esp->dma_regs = dma->regs;
 
         return 0;
 
@@ -70,18 +80,18 @@ static int __devinit esp_sbus_find_dma(struct esp *esp, struct sbus_dev *dma_sde
 
 static int __devinit esp_sbus_map_regs(struct esp *esp, int hme)
 {
-        struct sbus_dev *sdev = esp->dev;
+        struct of_device *op = esp->dev;
         struct resource *res;
 
         /* On HME, two reg sets exist, first is DVMA,
          * second is ESP registers.
          */
         if (hme)
-                res = &sdev->resource[1];
+                res = &op->resource[1];
         else
-                res = &sdev->resource[0];
+                res = &op->resource[0];
 
-        esp->regs = sbus_ioremap(res, 0, SBUS_ESP_REG_SIZE, "ESP");
+        esp->regs = of_ioremap(res, 0, SBUS_ESP_REG_SIZE, "ESP");
         if (!esp->regs)
                 return -ENOMEM;
 
@@ -90,10 +100,11 @@ static int __devinit esp_sbus_map_regs(struct esp *esp, int hme)
 
 static int __devinit esp_sbus_map_command_block(struct esp *esp)
 {
-        struct sbus_dev *sdev = esp->dev;
+        struct of_device *op = esp->dev;
 
-        esp->command_block = sbus_alloc_consistent(sdev, 16,
-                                                   &esp->command_block_dma);
+        esp->command_block = dma_alloc_coherent(&op->dev, 16,
+                                                &esp->command_block_dma,
+                                                GFP_ATOMIC);
         if (!esp->command_block)
                 return -ENOMEM;
         return 0;
@@ -102,17 +113,18 @@ static int __devinit esp_sbus_map_command_block(struct esp *esp)
 static int __devinit esp_sbus_register_irq(struct esp *esp)
 {
         struct Scsi_Host *host = esp->host;
-        struct sbus_dev *sdev = esp->dev;
+        struct of_device *op = esp->dev;
 
-        host->irq = sdev->irqs[0];
+        host->irq = op->irqs[0];
         return request_irq(host->irq, scsi_esp_intr, IRQF_SHARED, "ESP", esp);
 }
 
-static void __devinit esp_get_scsi_id(struct esp *esp)
+static void __devinit esp_get_scsi_id(struct esp *esp, struct of_device *espdma)
 {
-        struct sbus_dev *sdev = esp->dev;
-        struct device_node *dp = sdev->ofdev.node;
+        struct of_device *op = esp->dev;
+        struct device_node *dp;
 
+        dp = op->node;
         esp->scsi_id = of_getintprop_default(dp, "initiator-id", 0xff);
         if (esp->scsi_id != 0xff)
                 goto done;
@@ -121,13 +133,7 @@ static void __devinit esp_get_scsi_id(struct esp *esp)
         if (esp->scsi_id != 0xff)
                 goto done;
 
-        if (!sdev->bus) {
-                /* SUN4 */
-                esp->scsi_id = 7;
-                goto done;
-        }
-
-        esp->scsi_id = of_getintprop_default(sdev->bus->ofdev.node,
+        esp->scsi_id = of_getintprop_default(espdma->node,
                                              "scsi-initiator-id", 7);
 
 done:
@@ -137,9 +143,10 @@ done:
 
 static void __devinit esp_get_differential(struct esp *esp)
 {
-        struct sbus_dev *sdev = esp->dev;
-        struct device_node *dp = sdev->ofdev.node;
+        struct of_device *op = esp->dev;
+        struct device_node *dp;
 
+        dp = op->node;
         if (of_find_property(dp, "differential", NULL))
                 esp->flags |= ESP_FLAG_DIFFERENTIAL;
         else
@@ -148,43 +155,36 @@ static void __devinit esp_get_differential(struct esp *esp)
 
 static void __devinit esp_get_clock_params(struct esp *esp)
 {
-        struct sbus_dev *sdev = esp->dev;
-        struct device_node *dp = sdev->ofdev.node;
-        struct device_node *bus_dp;
+        struct of_device *op = esp->dev;
+        struct device_node *bus_dp, *dp;
         int fmhz;
 
-        bus_dp = NULL;
-        if (sdev != NULL && sdev->bus != NULL)
-                bus_dp = sdev->bus->ofdev.node;
+        dp = op->node;
+        bus_dp = dp->parent;
 
         fmhz = of_getintprop_default(dp, "clock-frequency", 0);
         if (fmhz == 0)
-                fmhz = (!bus_dp) ? 0 :
-                        of_getintprop_default(bus_dp, "clock-frequency", 0);
+                fmhz = of_getintprop_default(bus_dp, "clock-frequency", 0);
 
         esp->cfreq = fmhz;
 }
 
-static void __devinit esp_get_bursts(struct esp *esp, struct sbus_dev *dma)
+static void __devinit esp_get_bursts(struct esp *esp, struct of_device *dma_of)
 {
-        struct sbus_dev *sdev = esp->dev;
-        struct device_node *dp = sdev->ofdev.node;
-        u8 bursts;
+        struct device_node *dma_dp = dma_of->node;
+        struct of_device *op = esp->dev;
+        struct device_node *dp;
+        u8 bursts, val;
 
+        dp = op->node;
         bursts = of_getintprop_default(dp, "burst-sizes", 0xff);
-        if (dma) {
-                struct device_node *dma_dp = dma->ofdev.node;
-                u8 val = of_getintprop_default(dma_dp, "burst-sizes", 0xff);
-                if (val != 0xff)
-                        bursts &= val;
-        }
+        val = of_getintprop_default(dma_dp, "burst-sizes", 0xff);
+        if (val != 0xff)
+                bursts &= val;
 
-        if (sdev->bus) {
-                u8 val = of_getintprop_default(sdev->bus->ofdev.node,
-                                               "burst-sizes", 0xff);
-                if (val != 0xff)
-                        bursts &= val;
-        }
+        val = of_getintprop_default(dma_dp->parent, "burst-sizes", 0xff);
+        if (val != 0xff)
+                bursts &= val;
 
         if (bursts == 0xff ||
             (bursts & DMA_BURST16) == 0 ||
@@ -194,9 +194,9 @@ static void __devinit esp_get_bursts(struct esp *esp, struct sbus_dev *dma)
         esp->bursts = bursts;
 }
 
-static void __devinit esp_sbus_get_props(struct esp *esp, struct sbus_dev *espdma)
+static void __devinit esp_sbus_get_props(struct esp *esp, struct of_device *espdma)
 {
-        esp_get_scsi_id(esp);
+        esp_get_scsi_id(esp, espdma);
         esp_get_differential(esp);
         esp_get_clock_params(esp);
         esp_get_bursts(esp, espdma);
@@ -215,25 +215,33 @@ static u8 sbus_esp_read8(struct esp *esp, unsigned long reg)
 static dma_addr_t sbus_esp_map_single(struct esp *esp, void *buf,
                                       size_t sz, int dir)
 {
-        return sbus_map_single(esp->dev, buf, sz, dir);
+        struct of_device *op = esp->dev;
+
+        return dma_map_single(&op->dev, buf, sz, dir);
 }
 
 static int sbus_esp_map_sg(struct esp *esp, struct scatterlist *sg,
                                   int num_sg, int dir)
 {
-        return sbus_map_sg(esp->dev, sg, num_sg, dir);
+        struct of_device *op = esp->dev;
+
+        return dma_map_sg(&op->dev, sg, num_sg, dir);
 }
 
 static void sbus_esp_unmap_single(struct esp *esp, dma_addr_t addr,
                                   size_t sz, int dir)
 {
-        sbus_unmap_single(esp->dev, addr, sz, dir);
+        struct of_device *op = esp->dev;
+
+        dma_unmap_single(&op->dev, addr, sz, dir);
 }
 
 static void sbus_esp_unmap_sg(struct esp *esp, struct scatterlist *sg,
                               int num_sg, int dir)
 {
-        sbus_unmap_sg(esp->dev, sg, num_sg, dir);
+        struct of_device *op = esp->dev;
+
+        dma_unmap_sg(&op->dev, sg, num_sg, dir);
 }
 
 static int sbus_esp_irq_pending(struct esp *esp)
@@ -247,24 +255,26 @@ static void sbus_esp_reset_dma(struct esp *esp)
 {
         int can_do_burst16, can_do_burst32, can_do_burst64;
         int can_do_sbus64, lim;
+        struct of_device *op;
         u32 val;
 
         can_do_burst16 = (esp->bursts & DMA_BURST16) != 0;
         can_do_burst32 = (esp->bursts & DMA_BURST32) != 0;
         can_do_burst64 = 0;
         can_do_sbus64 = 0;
-        if (sbus_can_dma_64bit(esp->dev))
+        op = esp->dev;
+        if (sbus_can_dma_64bit())
                 can_do_sbus64 = 1;
-        if (sbus_can_burst64(esp->sdev))
+        if (sbus_can_burst64())
                 can_do_burst64 = (esp->bursts & DMA_BURST64) != 0;
 
         /* Put the DVMA into a known state. */
-        if (esp->dma->revision != dvmahme) {
+        if (esp->dmarev != dvmahme) {
                 val = dma_read32(DMA_CSR);
                 dma_write32(val | DMA_RST_SCSI, DMA_CSR);
                 dma_write32(val & ~DMA_RST_SCSI, DMA_CSR);
         }
-        switch (esp->dma->revision) {
+        switch (esp->dmarev) {
         case dvmahme:
                 dma_write32(DMA_RESET_FAS366, DMA_CSR);
                 dma_write32(DMA_RST_SCSI, DMA_CSR);
@@ -282,7 +292,7 @@ static void sbus_esp_reset_dma(struct esp *esp)
 
                 if (can_do_sbus64) {
                         esp->prev_hme_dmacsr |= DMA_SCSI_SBUS64;
-                        sbus_set_sbus64(esp->dev, esp->bursts);
+                        sbus_set_sbus64(&op->dev, esp->bursts);
                 }
 
                 lim = 1000;
@@ -346,14 +356,14 @@ static void sbus_esp_dma_drain(struct esp *esp)
         u32 csr;
         int lim;
 
-        if (esp->dma->revision == dvmahme)
+        if (esp->dmarev == dvmahme)
                 return;
 
         csr = dma_read32(DMA_CSR);
         if (!(csr & DMA_FIFO_ISDRAIN))
                 return;
 
-        if (esp->dma->revision != dvmarev3 && esp->dma->revision != dvmaesc1)
+        if (esp->dmarev != dvmarev3 && esp->dmarev != dvmaesc1)
                 dma_write32(csr | DMA_FIFO_STDRAIN, DMA_CSR);
 
         lim = 1000;
@@ -369,7 +379,7 @@ static void sbus_esp_dma_drain(struct esp *esp)
 
 static void sbus_esp_dma_invalidate(struct esp *esp)
 {
-        if (esp->dma->revision == dvmahme) {
+        if (esp->dmarev == dvmahme) {
                 dma_write32(DMA_RST_SCSI, DMA_CSR);
 
                 esp->prev_hme_dmacsr = ((esp->prev_hme_dmacsr |
@@ -440,7 +450,7 @@ static void sbus_esp_send_dma_cmd(struct esp *esp, u32 addr, u32 esp_count,
                 else
                         csr &= ~DMA_ST_WRITE;
                 dma_write32(csr, DMA_CSR);
-                if (esp->dma->revision == dvmaesc1) {
+                if (esp->dmarev == dvmaesc1) {
                         u32 end = PAGE_ALIGN(addr + dma_count + 16U);
                         dma_write32(end - addr, DMA_COUNT);
                 }
@@ -476,10 +486,8 @@ static const struct esp_driver_ops sbus_esp_ops = {
         .dma_error      =       sbus_esp_dma_error,
 };
 
-static int __devinit esp_sbus_probe_one(struct device *dev,
-                                        struct sbus_dev *esp_dev,
-                                        struct sbus_dev *espdma,
-                                        struct sbus_bus *sbus,
+static int __devinit esp_sbus_probe_one(struct of_device *op,
+                                        struct of_device *espdma,
                                         int hme)
 {
         struct scsi_host_template *tpnt = &scsi_esp_template;
@@ -497,13 +505,13 @@ static int __devinit esp_sbus_probe_one(struct device *dev,
         esp = shost_priv(host);
 
         esp->host = host;
-        esp->dev = esp_dev;
+        esp->dev = op;
         esp->ops = &sbus_esp_ops;
 
         if (hme)
                 esp->flags |= ESP_FLAG_WIDE_CAPABLE;
 
-        err = esp_sbus_find_dma(esp, espdma);
+        err = esp_sbus_setup_dma(esp, espdma);
         if (err < 0)
                 goto fail_unlink;
 
@@ -525,15 +533,15 @@ static int __devinit esp_sbus_probe_one(struct device *dev,
          * come up with the reset bit set, so make sure that
          * is clear first.
          */
-        if (esp->dma->revision == dvmaesc1) {
+        if (esp->dmarev == dvmaesc1) {
                 u32 val = dma_read32(DMA_CSR);
 
                 dma_write32(val & ~DMA_RST_SCSI, DMA_CSR);
         }
 
-        dev_set_drvdata(&esp_dev->ofdev.dev, esp);
+        dev_set_drvdata(&op->dev, esp);
 
-        err = scsi_esp_register(esp, dev);
+        err = scsi_esp_register(esp, &op->dev);
         if (err)
                 goto fail_free_irq;
 
@@ -542,41 +550,46 @@ static int __devinit esp_sbus_probe_one(struct device *dev,
 fail_free_irq:
         free_irq(host->irq, esp);
 fail_unmap_command_block:
-        sbus_free_consistent(esp->dev, 16,
-                             esp->command_block,
-                             esp->command_block_dma);
+        dma_free_coherent(&op->dev, 16,
+                          esp->command_block,
+                          esp->command_block_dma);
 fail_unmap_regs:
-        sbus_iounmap(esp->regs, SBUS_ESP_REG_SIZE);
+        of_iounmap(&op->resource[(hme ? 1 : 0)], esp->regs, SBUS_ESP_REG_SIZE);
 fail_unlink:
         scsi_host_put(host);
 fail:
         return err;
 }
 
-static int __devinit esp_sbus_probe(struct of_device *dev, const struct of_device_id *match)
+static int __devinit esp_sbus_probe(struct of_device *op, const struct of_device_id *match)
 {
-        struct sbus_dev *sdev = to_sbus_device(&dev->dev);
-        struct device_node *dp = dev->node;
-        struct sbus_dev *dma_sdev = NULL;
+        struct device_node *dma_node = NULL;
+        struct device_node *dp = op->node;
+        struct of_device *dma_of = NULL;
         int hme = 0;
 
         if (dp->parent &&
             (!strcmp(dp->parent->name, "espdma") ||
              !strcmp(dp->parent->name, "dma")))
-                dma_sdev = sdev->parent;
+                dma_node = dp->parent;
         else if (!strcmp(dp->name, "SUNW,fas")) {
-                dma_sdev = sdev;
+                dma_node = op->node;
                 hme = 1;
         }
+        if (dma_node)
+                dma_of = of_find_device_by_node(dma_node);
+        if (!dma_of)
+                return -ENODEV;
 
-        return esp_sbus_probe_one(&dev->dev, sdev, dma_sdev,
-                                  sdev->bus, hme);
+        return esp_sbus_probe_one(op, dma_of, hme);
 }
 
-static int __devexit esp_sbus_remove(struct of_device *dev)
+static int __devexit esp_sbus_remove(struct of_device *op)
 {
-        struct esp *esp = dev_get_drvdata(&dev->dev);
+        struct esp *esp = dev_get_drvdata(&op->dev);
+        struct of_device *dma_of = esp->dma;
         unsigned int irq = esp->host->irq;
+        bool is_hme;
         u32 val;
 
         scsi_esp_unregister(esp);
@@ -586,17 +599,25 @@ static int __devexit esp_sbus_remove(struct of_device *dev)
         dma_write32(val & ~DMA_INT_ENAB, DMA_CSR);
 
         free_irq(irq, esp);
-        sbus_free_consistent(esp->dev, 16,
-                             esp->command_block,
-                             esp->command_block_dma);
-        sbus_iounmap(esp->regs, SBUS_ESP_REG_SIZE);
+
+        is_hme = (esp->dmarev == dvmahme);
+
+        dma_free_coherent(&op->dev, 16,
+                          esp->command_block,
+                          esp->command_block_dma);
+        of_iounmap(&op->resource[(is_hme ? 1 : 0)], esp->regs,
+                   SBUS_ESP_REG_SIZE);
+        of_iounmap(&dma_of->resource[0], esp->dma_regs,
+                   resource_size(&dma_of->resource[0]));
 
         scsi_host_put(esp->host);
 
+        dev_set_drvdata(&op->dev, NULL);
+
         return 0;
 }
 
-static struct of_device_id esp_match[] = {
+static const struct of_device_id esp_match[] = {
         {
                 .name = "SUNW,esp",
         },
@@ -619,7 +640,7 @@ static struct of_platform_driver esp_sbus_driver = {
 
 static int __init sunesp_init(void)
 {
-        return of_register_driver(&esp_sbus_driver, &sbus_bus_type);
+        return of_register_driver(&esp_sbus_driver, &of_bus_type);
 }
 
 static void __exit sunesp_exit(void)