[SBUS]: Rewrite and plug into of_device framework.
[linux-3.10.git] / arch / sparc64 / kernel / sbus.c
index d3eca98..d3da23c 100644 (file)
@@ -19,6 +19,7 @@
 #include <asm/cache.h>
 #include <asm/dma.h>
 #include <asm/irq.h>
+#include <asm/prom.h>
 #include <asm/starfire.h>
 
 #include "iommu_common.h"
@@ -117,29 +118,37 @@ static void iommu_flush(struct sbus_iommu *iommu, u32 base, unsigned long npages
 
 #define STRBUF_TAG_VALID       0x02UL
 
-static void sbus_strbuf_flush(struct sbus_iommu *iommu, u32 base, unsigned long npages)
+static void sbus_strbuf_flush(struct sbus_iommu *iommu, u32 base, unsigned long npages, int direction)
 {
        unsigned long n;
        int limit;
 
-       iommu->strbuf_flushflag = 0UL;
        n = npages;
        while (n--)
                upa_writeq(base + (n << IO_PAGE_SHIFT),
                           iommu->strbuf_regs + STRBUF_PFLUSH);
 
+       /* If the device could not have possibly put dirty data into
+        * the streaming cache, no flush-flag synchronization needs
+        * to be performed.
+        */
+       if (direction == SBUS_DMA_TODEVICE)
+               return;
+
+       iommu->strbuf_flushflag = 0UL;
+
        /* Whoopee cushion! */
        upa_writeq(__pa(&iommu->strbuf_flushflag),
                   iommu->strbuf_regs + STRBUF_FSYNC);
        upa_readq(iommu->sbus_control_reg);
 
-       limit = 10000;
+       limit = 100000;
        while (iommu->strbuf_flushflag == 0UL) {
                limit--;
                if (!limit)
                        break;
-               udelay(10);
-               membar("#LoadLoad");
+               udelay(1);
+               rmb();
        }
        if (!limit)
                printk(KERN_WARNING "sbus_strbuf_flush: flushflag timeout "
@@ -319,7 +328,7 @@ void *sbus_alloc_consistent(struct sbus_dev *sdev, size_t size, dma_addr_t *dvma
        order = get_order(size);
        if (order >= 10)
                return NULL;
-       first_page = __get_free_pages(GFP_KERNEL, order);
+       first_page = __get_free_pages(GFP_KERNEL|__GFP_COMP, order);
        if (first_page == 0UL)
                return NULL;
        memset((char *)first_page, 0, PAGE_SIZE << order);
@@ -421,7 +430,7 @@ void sbus_unmap_single(struct sbus_dev *sdev, dma_addr_t dma_addr, size_t size,
 
        spin_lock_irqsave(&iommu->lock, flags);
        free_streaming_cluster(iommu, dma_base, size >> IO_PAGE_SHIFT);
-       sbus_strbuf_flush(iommu, dma_base, size >> IO_PAGE_SHIFT);
+       sbus_strbuf_flush(iommu, dma_base, size >> IO_PAGE_SHIFT, direction);
        spin_unlock_irqrestore(&iommu->lock, flags);
 }
 
@@ -584,7 +593,7 @@ void sbus_unmap_sg(struct sbus_dev *sdev, struct scatterlist *sg, int nents, int
        iommu = sdev->bus->iommu;
        spin_lock_irqsave(&iommu->lock, flags);
        free_streaming_cluster(iommu, dvma_base, size >> IO_PAGE_SHIFT);
-       sbus_strbuf_flush(iommu, dvma_base, size >> IO_PAGE_SHIFT);
+       sbus_strbuf_flush(iommu, dvma_base, size >> IO_PAGE_SHIFT, direction);
        spin_unlock_irqrestore(&iommu->lock, flags);
 }
 
@@ -596,7 +605,7 @@ void sbus_dma_sync_single_for_cpu(struct sbus_dev *sdev, dma_addr_t base, size_t
        size = (IO_PAGE_ALIGN(base + size) - (base & IO_PAGE_MASK));
 
        spin_lock_irqsave(&iommu->lock, flags);
-       sbus_strbuf_flush(iommu, base & IO_PAGE_MASK, size >> IO_PAGE_SHIFT);
+       sbus_strbuf_flush(iommu, base & IO_PAGE_MASK, size >> IO_PAGE_SHIFT, direction);
        spin_unlock_irqrestore(&iommu->lock, flags);
 }
 
@@ -620,7 +629,7 @@ void sbus_dma_sync_sg_for_cpu(struct sbus_dev *sdev, struct scatterlist *sg, int
        size = IO_PAGE_ALIGN(sg[i].dma_address + sg[i].dma_length) - base;
 
        spin_lock_irqsave(&iommu->lock, flags);
-       sbus_strbuf_flush(iommu, base, size >> IO_PAGE_SHIFT);
+       sbus_strbuf_flush(iommu, base, size >> IO_PAGE_SHIFT, direction);
        spin_unlock_irqrestore(&iommu->lock, flags);
 }
 
@@ -683,36 +692,6 @@ void sbus_set_sbus64(struct sbus_dev *sdev, int bursts)
        upa_writeq(val, cfg_reg);
 }
 
-/* SBUS SYSIO INO number to Sparc PIL level. */
-static unsigned char sysio_ino_to_pil[] = {
-       0, 4, 4, 7, 5, 7, 8, 9,         /* SBUS slot 0 */
-       0, 4, 4, 7, 5, 7, 8, 9,         /* SBUS slot 1 */
-       0, 4, 4, 7, 5, 7, 8, 9,         /* SBUS slot 2 */
-       0, 4, 4, 7, 5, 7, 8, 9,         /* SBUS slot 3 */
-       4, /* Onboard SCSI */
-       5, /* Onboard Ethernet */
-/*XXX*/        8, /* Onboard BPP */
-       0, /* Bogon */
-       13, /* Audio */
-/*XXX*/15, /* PowerFail */
-       0, /* Bogon */
-       0, /* Bogon */
-       12, /* Zilog Serial Channels (incl. Keyboard/Mouse lines) */
-       11, /* Floppy */
-       0, /* Spare Hardware (bogon for now) */
-       0, /* Keyboard (bogon for now) */
-       0, /* Mouse (bogon for now) */
-       0, /* Serial (bogon for now) */
-     0, 0, /* Bogon, Bogon */
-       10, /* Timer 0 */
-       11, /* Timer 1 */
-     0, 0, /* Bogon, Bogon */
-       15, /* Uncorrectable SBUS Error */
-       15, /* Correctable SBUS Error */
-       15, /* SBUS Error */
-/*XXX*/ 0, /* Power Management (bogon for now) */
-};
-
 /* INO number to IMAP register offset for SYSIO external IRQ's.
  * This should conform to both Sunfire/Wildfire server and Fusion
  * desktop designs.
@@ -782,7 +761,7 @@ static unsigned long sysio_irq_offsets[] = {
 
 #undef bogon
 
-#define NUM_SYSIO_OFFSETS (sizeof(sysio_irq_offsets) / sizeof(sysio_irq_offsets[0]))
+#define NUM_SYSIO_OFFSETS ARRAY_SIZE(sysio_irq_offsets)
 
 /* Convert Interrupt Mapping register pointer to associated
  * Interrupt Clear register pointer, SYSIO specific version.
@@ -804,21 +783,12 @@ unsigned int sbus_build_irq(void *buscookie, unsigned int ino)
        struct sbus_iommu *iommu = sbus->iommu;
        unsigned long reg_base = iommu->sbus_control_reg - 0x2000UL;
        unsigned long imap, iclr;
-       int pil, sbus_level = 0;
-
-       pil = sysio_ino_to_pil[ino];
-       if (!pil) {
-               printk("sbus_irq_build: Bad SYSIO INO[%x]\n", ino);
-               panic("Bad SYSIO IRQ translations...");
-       }
-
-       if (PIL_RESERVED(pil))
-               BUG();
+       int sbus_level = 0;
 
        imap = sysio_irq_offsets[ino];
        if (imap == ((unsigned long)-1)) {
-               prom_printf("get_irq_translations: Bad SYSIO INO[%x] cpu[%d]\n",
-                           ino, pil);
+               prom_printf("get_irq_translations: Bad SYSIO INO[%x]\n",
+                           ino);
                prom_halt();
        }
        imap += reg_base;
@@ -852,7 +822,7 @@ unsigned int sbus_build_irq(void *buscookie, unsigned int ino)
 
                iclr += ((unsigned long)sbus_level - 1UL) * 8UL;
        }
-       return build_irq(pil, sbus_level, iclr, imap);
+       return build_irq(sbus_level, iclr, imap);
 }
 
 /* Error interrupt handling. */
@@ -1129,24 +1099,25 @@ static void __init sysio_register_error_handlers(struct sbus_bus *sbus)
 }
 
 /* Boot time initialization. */
-void __init sbus_iommu_init(int prom_node, struct sbus_bus *sbus)
+static void __init sbus_iommu_init(int __node, struct sbus_bus *sbus)
 {
-       struct linux_prom64_registers rprop;
+       struct linux_prom64_registers *pr;
+       struct device_node *dp;
        struct sbus_iommu *iommu;
        unsigned long regs, tsb_base;
        u64 control;
-       int err, i;
+       int i;
 
-       sbus->portid = prom_getintdefault(sbus->prom_node,
-                                         "upa-portid", -1);
+       dp = of_find_node_by_phandle(__node);
 
-       err = prom_getproperty(prom_node, "reg",
-                              (char *)&rprop, sizeof(rprop));
-       if (err < 0) {
+       sbus->portid = of_getintprop_default(dp, "upa-portid", -1);
+
+       pr = of_get_property(dp, "reg", NULL);
+       if (!pr) {
                prom_printf("sbus_iommu_init: Cannot map SYSIO control registers.\n");
                prom_halt();
        }
-       regs = rprop.phys_addr;
+       regs = pr->phys_addr;
 
        iommu = kmalloc(sizeof(*iommu) + SMP_CACHE_BYTES, GFP_ATOMIC);
        if (iommu == NULL) {
@@ -1256,3 +1227,52 @@ void __init sbus_iommu_init(int prom_node, struct sbus_bus *sbus)
 
        sysio_register_error_handlers(sbus);
 }
+
+void sbus_fill_device_irq(struct sbus_dev *sdev)
+{
+       struct device_node *dp = of_find_node_by_phandle(sdev->prom_node);
+       struct linux_prom_irqs *irqs;
+
+       irqs = of_get_property(dp, "interrupts", NULL);
+       if (!irqs) {
+               sdev->irqs[0] = 0;
+               sdev->num_irqs = 0;
+       } else {
+               unsigned int pri = irqs[0].pri;
+
+               sdev->num_irqs = 1;
+               if (pri < 0x20)
+                       pri += sdev->slot * 8;
+
+               sdev->irqs[0] = sbus_build_irq(sdev->bus, pri);
+       }
+}
+
+void __init sbus_arch_bus_ranges_init(struct device_node *pn, struct sbus_bus *sbus)
+{
+}
+
+void __init sbus_setup_iommu(struct sbus_bus *sbus, struct device_node *dp)
+{
+       sbus_iommu_init(dp->node, sbus);
+}
+
+void __init sbus_setup_arch_props(struct sbus_bus *sbus, struct device_node *dp)
+{
+}
+
+int __init sbus_arch_preinit(void)
+{
+       return 0;
+}
+
+void __init sbus_arch_postinit(void)
+{
+       extern void firetruck_init(void);
+       extern void auxio_probe(void);
+       extern void clock_probe(void);
+
+       firetruck_init();
+       auxio_probe();
+       clock_probe();
+}