#include <linux/init.h>
 
 struct sparc64_tick_ops {
-       unsigned long (*get_tick)(void);
+       unsigned long long (*get_tick)(void);
        int (*add_compare)(unsigned long);
        unsigned long softint_mask;
        void (*disable_irq)(void);
 
 #if defined(__sparc__) && defined(__arch64__)
 
 /*** SPARC 64 bit ***/
-#include <asm-generic/int-l64.h>
+#include <asm-generic/int-ll64.h>
 
 #ifndef __ASSEMBLY__
 
 
 
        rp = (struct ds_md_update_req *) (dpkt + 1);
 
-       printk(KERN_INFO "ds-%lu: Machine description update.\n", dp->id);
+       printk(KERN_INFO "ds-%llu: Machine description update.\n", dp->id);
 
        mdesc_update();
 
 
        rp = (struct ds_shutdown_req *) (dpkt + 1);
 
-       printk(KERN_ALERT "ds-%lu: Shutdown request from "
+       printk(KERN_ALERT "ds-%llu: Shutdown request from "
               "LDOM manager received.\n", dp->id);
 
        memset(&pkt, 0, sizeof(pkt));
 
        rp = (struct ds_panic_req *) (dpkt + 1);
 
-       printk(KERN_ALERT "ds-%lu: Panic request from "
+       printk(KERN_ALERT "ds-%llu: Panic request from "
               "LDOM manager received.\n", dp->id);
 
        memset(&pkt, 0, sizeof(pkt));
        for_each_cpu_mask(cpu, *mask) {
                int err;
 
-               printk(KERN_INFO "ds-%lu: Starting cpu %d...\n",
+               printk(KERN_INFO "ds-%llu: Starting cpu %d...\n",
                       dp->id, cpu);
                err = cpu_up(cpu);
                if (err) {
                                res = DR_CPU_RES_CPU_NOT_RESPONDING;
                        }
 
-                       printk(KERN_INFO "ds-%lu: CPU startup failed err=%d\n",
+                       printk(KERN_INFO "ds-%llu: CPU startup failed err=%d\n",
                               dp->id, err);
                        dr_cpu_mark(resp, cpu, ncpus, res, stat);
                }
        for_each_cpu_mask(cpu, *mask) {
                int err;
 
-               printk(KERN_INFO "ds-%lu: Shutting down cpu %d...\n",
+               printk(KERN_INFO "ds-%llu: Shutting down cpu %d...\n",
                       dp->id, cpu);
                err = cpu_down(cpu);
                if (err)
 
        rp = (struct ds_pri_msg *) (dpkt + 1);
 
-       printk(KERN_INFO "ds-%lu: PRI REQ [%lx:%lx], len=%d\n",
+       printk(KERN_INFO "ds-%llu: PRI REQ [%llx:%llx], len=%d\n",
               dp->id, rp->req_num, rp->type, len);
 }
 
 
                if (ds_var_doorbell == 0 ||
                    ds_var_response != DS_VAR_SUCCESS)
-                       printk(KERN_ERR "ds-%lu: var-config [%s:%s] "
+                       printk(KERN_ERR "ds-%llu: var-config [%s:%s] "
                               "failed, response(%d).\n",
                               dp->id, var, value,
                               ds_var_response);
 
 static void ds_conn_reset(struct ds_info *dp)
 {
-       printk(KERN_ERR "ds-%lu: ds_conn_reset() from %p\n",
+       printk(KERN_ERR "ds-%llu: ds_conn_reset() from %p\n",
               dp->id, __builtin_return_address(0));
 }
 
                struct ds_cap_state *cp = find_cap(dp, ap->handle);
 
                if (!cp) {
-                       printk(KERN_ERR "ds-%lu: REG ACK for unknown "
-                              "handle %lx\n", dp->id, ap->handle);
+                       printk(KERN_ERR "ds-%llu: REG ACK for unknown "
+                              "handle %llx\n", dp->id, ap->handle);
                        return 0;
                }
-               printk(KERN_INFO "ds-%lu: Registered %s service.\n",
+               printk(KERN_INFO "ds-%llu: Registered %s service.\n",
                       dp->id, cp->service_id);
                cp->state = CAP_STATE_REGISTERED;
        } else if (pkt->type == DS_REG_NACK) {
                struct ds_cap_state *cp = find_cap(dp, np->handle);
 
                if (!cp) {
-                       printk(KERN_ERR "ds-%lu: REG NACK for "
-                              "unknown handle %lx\n",
+                       printk(KERN_ERR "ds-%llu: REG NACK for "
+                              "unknown handle %llx\n",
                               dp->id, np->handle);
                        return 0;
                }
                int req_len = qp->req_len;
 
                if (!cp) {
-                       printk(KERN_ERR "ds-%lu: Data for unknown "
-                              "handle %lu\n",
+                       printk(KERN_ERR "ds-%llu: Data for unknown "
+                              "handle %llu\n",
                               dp->id, dpkt->handle);
 
                        spin_lock_irqsave(&ds_lock, flags);
        }
 
        if (event != LDC_EVENT_DATA_READY) {
-               printk(KERN_WARNING "ds-%lu: Unexpected LDC event %d\n",
+               printk(KERN_WARNING "ds-%llu: Unexpected LDC event %d\n",
                       dp->id, event);
                spin_unlock_irqrestore(&ds_lock, flags);
                return;
 
                val = iommu_read(matchreg);
                if (unlikely(val)) {
                        printk(KERN_WARNING "strbuf_flush: ctx flush "
-                              "timeout matchreg[%lx] ctx[%lx]\n",
+                              "timeout matchreg[%llx] ctx[%lx]\n",
                               val, ctx);
                        goto do_page_flush;
                }
 
 
        v = mdesc_get_property(hp, pn, "hostid", NULL);
        if (v)
-               printk("PLATFORM: hostid [%08lx]\n", *v);
+               printk("PLATFORM: hostid [%08llx]\n", *v);
        v = mdesc_get_property(hp, pn, "serial#", NULL);
        if (v)
-               printk("PLATFORM: serial# [%08lx]\n", *v);
+               printk("PLATFORM: serial# [%08llx]\n", *v);
        v = mdesc_get_property(hp, pn, "stick-frequency", NULL);
-       printk("PLATFORM: stick-frequency [%08lx]\n", *v);
+       printk("PLATFORM: stick-frequency [%08llx]\n", *v);
        v = mdesc_get_property(hp, pn, "mac-address", NULL);
        if (v)
-               printk("PLATFORM: mac-address [%lx]\n", *v);
+               printk("PLATFORM: mac-address [%llx]\n", *v);
        v = mdesc_get_property(hp, pn, "watchdog-resolution", NULL);
        if (v)
-               printk("PLATFORM: watchdog-resolution [%lu ms]\n", *v);
+               printk("PLATFORM: watchdog-resolution [%llu ms]\n", *v);
        v = mdesc_get_property(hp, pn, "watchdog-max-timeout", NULL);
        if (v)
-               printk("PLATFORM: watchdog-max-timeout [%lu ms]\n", *v);
+               printk("PLATFORM: watchdog-max-timeout [%llu ms]\n", *v);
        v = mdesc_get_property(hp, pn, "max-cpus", NULL);
        if (v)
-               printk("PLATFORM: max-cpus [%lu]\n", *v);
+               printk("PLATFORM: max-cpus [%llu]\n", *v);
 
 #ifdef CONFIG_SMP
        {
 
                memset(r, 0, sizeof(*r));
 
                if (of_resource_verbose)
-                       printk("%s reg[%d] -> %lx\n",
+                       printk("%s reg[%d] -> %llx\n",
                               op->node->full_name, index,
                               result);
 
 
                        continue;
                i = addrs[0] & 0xff;
                if (ofpci_verbose)
-                       printk("  start: %lx, end: %lx, i: %x\n",
+                       printk("  start: %llx, end: %llx, i: %x\n",
                               op_res->start, op_res->end, i);
 
                if (PCI_BASE_ADDRESS_0 <= i && i <= PCI_BASE_ADDRESS_5) {
 
                prom_halt();
        }
 
-       printk("%s: PCI IO[%lx] MEM[%lx]\n",
+       printk("%s: PCI IO[%llx] MEM[%llx]\n",
               pbm->name,
               pbm->io_space.start,
               pbm->mem_space.start);
 
                       pbm->name,
                       pbm->msi_first, pbm->msi_num, pbm->msi_data_mask,
                       pbm->msix_data_width);
-               printk(KERN_INFO "%s: MSI addr32[0x%lx:0x%x] "
-                      "addr64[0x%lx:0x%x]\n",
+               printk(KERN_INFO "%s: MSI addr32[0x%llx:0x%x] "
+                      "addr64[0x%llx:0x%x]\n",
                       pbm->name,
                       pbm->msi32_start, pbm->msi32_len,
                       pbm->msi64_start, pbm->msi64_len);
 
                   pbm->controller_regs + SCHIZO_SAFARI_ERRLOG);
 
        if (!(errlog & BUS_ERROR_UNMAP)) {
-               printk("%s: Unexpected Safari/JBUS error interrupt, errlog[%016lx]\n",
+               printk("%s: Unexpected Safari/JBUS error interrupt, errlog[%016llx]\n",
                       pbm->name, errlog);
 
                return IRQ_HANDLED;
 
                if (unlikely(num < 0)) {
                        if (printk_ratelimit())
                                printk("iommu_batch_flush: IOMMU map of "
-                                      "[%08lx:%08lx:%lx:%lx:%lx] failed with "
+                                      "[%08lx:%08llx:%lx:%lx:%lx] failed with "
                                       "status %ld\n",
                                       devhandle, HV_PCI_TSBID(0, entry),
                                       npages, prot, __pa(pglist), num);
 
 
        power_reg = of_ioremap(res, 0, 0x4, "power");
 
-       printk(KERN_INFO "%s: Control reg at %lx\n",
+       printk(KERN_INFO "%s: Control reg at %llx\n",
               op->node->name, res->start);
 
        if (has_button_interrupt(irq, op->node)) {
 
                        break;
        }
        if (limit <= 0) {
-               printk("tomatillo_wsync_handler: DMA won't sync [%lx:%lx]\n",
+               printk("tomatillo_wsync_handler: DMA won't sync [%llx:%llx]\n",
                       val, mask);
        }
 
 
                if (saw_error != 0) {
                        u64 tagval = stc_tag_buf[i];
                        u64 lineval = stc_line_buf[i];
-                       printk(KERN_ERR "%s: STC_TAG(%d)[PA(%016lx)VA(%08lx)"
+                       printk(KERN_ERR "%s: STC_TAG(%d)[PA(%016llx)VA(%08llx)"
                               "V(%d)W(%d)]\n",
                               pbm->name,
                               i,
                               (tagval & PSYCHO_STCTAG_VPN),
                               ((tagval & PSYCHO_STCTAG_VALID) ? 1 : 0),
                               ((tagval & PSYCHO_STCTAG_WRITE) ? 1 : 0));
-                       printk(KERN_ERR "%s: STC_LINE(%d)[LIDX(%lx)SP(%lx)"
-                              "LADDR(%lx)EP(%lx)V(%d)FOFN(%d)]\n",
+                       printk(KERN_ERR "%s: STC_LINE(%d)[LIDX(%llx)SP(%llx)"
+                              "LADDR(%llx)EP(%llx)V(%d)FOFN(%d)]\n",
                               pbm->name,
                               i,
                               ((lineval & PSYCHO_STCLINE_LINDX) >> 21UL),
                }
 
                printk(KERN_ERR "%s: IOMMU TAG(%d)[error(%s) wr(%d) "
-                      "str(%d) sz(%dK) vpg(%08lx)]\n",
+                      "str(%d) sz(%dK) vpg(%08llx)]\n",
                       pbm->name, i, type_str,
                       ((tag_val & PSYCHO_IOMMU_TAG_WRITE) ? 1 : 0),
                       ((tag_val & PSYCHO_IOMMU_TAG_STREAM) ? 1 : 0),
                       ((tag_val & PSYCHO_IOMMU_TAG_SIZE) ? 64 : 8),
                       (tag_val & PSYCHO_IOMMU_TAG_VPAGE) << IOMMU_PAGE_SHIFT);
                printk(KERN_ERR "%s: IOMMU DATA(%d)[valid(%d) cache(%d) "
-                      "ppg(%016lx)]\n",
+                      "ppg(%016llx)]\n",
                       pbm->name, i,
                       ((data_val & PSYCHO_IOMMU_DATA_VALID) ? 1 : 0),
                       ((data_val & PSYCHO_IOMMU_DATA_CACHE) ? 1 : 0),
                   "Excessive Retries" :
                   ((error_bits & PSYCHO_PCIAFSR_PPERR) ?
                    "Parity Error" : "???"))))));
-       printk(KERN_ERR "%s: bytemask[%04lx] UPA_MID[%02lx] was_block(%d)\n",
+       printk(KERN_ERR "%s: bytemask[%04llx] UPA_MID[%02llx] was_block(%d)\n",
               pbm->name,
               (afsr & PSYCHO_PCIAFSR_BMSK) >> 32UL,
               (afsr & PSYCHO_PCIAFSR_MID) >> 25UL,
               (afsr & PSYCHO_PCIAFSR_BLK) ? 1 : 0);
-       printk(KERN_ERR "%s: PCI AFAR [%016lx]\n", pbm->name, afar);
+       printk(KERN_ERR "%s: PCI AFAR [%016llx]\n", pbm->name, afar);
        printk(KERN_ERR "%s: PCI Secondary errors [", pbm->name);
        reported = 0;
        if (afsr & PSYCHO_PCIAFSR_SMA) {
 
        __asm__ __volatile__("wrpr %0, 0x0, %%pstate"
                             : : "r" (pstate));
        if (stuck == 0) {
-               printk("CPU[%d]: mondo stuckage result[%016lx]\n",
+               printk("CPU[%d]: mondo stuckage result[%016llx]\n",
                       smp_processor_id(), result);
        } else {
                udelay(2);
                        /* Busy bits will not clear, continue instead
                         * of freezing up on this cpu.
                         */
-                       printk("CPU[%d]: mondo stuckage result[%016lx]\n",
+                       printk("CPU[%d]: mondo stuckage result[%016llx]\n",
                               smp_processor_id(), dispatch_stat);
                } else {
                        int i, this_busy_nack = 0;
 
        tick_disable_irq();
 }
 
-static unsigned long tick_get_tick(void)
+static unsigned long long tick_get_tick(void)
 {
        unsigned long ret;
 
        stick_disable_irq();
 }
 
-static unsigned long stick_get_tick(void)
+static unsigned long long stick_get_tick(void)
 {
        unsigned long ret;
 
        hbtick_disable_irq();
 }
 
-static unsigned long hbtick_get_tick(void)
+static unsigned long long hbtick_get_tick(void)
 {
        return __hbird_read_stick() & ~TICK_PRIV_BIT;
 }
 {
        struct resource *r;
 
-       printk(KERN_INFO "%s: RTC regs at 0x%lx\n",
+       printk(KERN_INFO "%s: RTC regs at 0x%llx\n",
               op->node->full_name, op->resource[0].start);
 
        /* The CMOS RTC driver only accepts IORESOURCE_IO, so cons
 static int __devinit bq4802_probe(struct of_device *op, const struct of_device_id *match)
 {
 
-       printk(KERN_INFO "%s: BQ4802 regs at 0x%lx\n",
+       printk(KERN_INFO "%s: BQ4802 regs at 0x%llx\n",
               op->node->full_name, op->resource[0].start);
 
        rtc_bq4802_device.resource = &op->resource[0];
            strcmp(dp->parent->parent->name, "central") != 0)
                return -ENODEV;
 
-       printk(KERN_INFO "%s: Mostek regs at 0x%lx\n",
+       printk(KERN_INFO "%s: Mostek regs at 0x%llx\n",
               dp->full_name, op->resource[0].start);
 
        m48t59_rtc.resource = &op->resource[0];
 
        }
 
        /* Now dump the cache snapshots. */
-       printk("%s" "ERROR(%d): D-cache idx[%x] tag[%016lx] utag[%016lx] stag[%016lx]\n",
+       printk("%s" "ERROR(%d): D-cache idx[%x] tag[%016llx] utag[%016llx] stag[%016llx]\n",
               (recoverable ? KERN_WARNING : KERN_CRIT), smp_processor_id(),
               (int) info->dcache_index,
               info->dcache_tag,
               info->dcache_utag,
               info->dcache_stag);
-       printk("%s" "ERROR(%d): D-cache data0[%016lx] data1[%016lx] data2[%016lx] data3[%016lx]\n",
+       printk("%s" "ERROR(%d): D-cache data0[%016llx] data1[%016llx] data2[%016llx] data3[%016llx]\n",
               (recoverable ? KERN_WARNING : KERN_CRIT), smp_processor_id(),
               info->dcache_data[0],
               info->dcache_data[1],
               info->dcache_data[2],
               info->dcache_data[3]);
-       printk("%s" "ERROR(%d): I-cache idx[%x] tag[%016lx] utag[%016lx] stag[%016lx] "
-              "u[%016lx] l[%016lx]\n",
+       printk("%s" "ERROR(%d): I-cache idx[%x] tag[%016llx] utag[%016llx] stag[%016llx] "
+              "u[%016llx] l[%016llx]\n",
               (recoverable ? KERN_WARNING : KERN_CRIT), smp_processor_id(),
               (int) info->icache_index,
               info->icache_tag,
               info->icache_stag,
               info->icache_upper,
               info->icache_lower);
-       printk("%s" "ERROR(%d): I-cache INSN0[%016lx] INSN1[%016lx] INSN2[%016lx] INSN3[%016lx]\n",
+       printk("%s" "ERROR(%d): I-cache INSN0[%016llx] INSN1[%016llx] INSN2[%016llx] INSN3[%016llx]\n",
               (recoverable ? KERN_WARNING : KERN_CRIT), smp_processor_id(),
               info->icache_data[0],
               info->icache_data[1],
               info->icache_data[2],
               info->icache_data[3]);
-       printk("%s" "ERROR(%d): I-cache INSN4[%016lx] INSN5[%016lx] INSN6[%016lx] INSN7[%016lx]\n",
+       printk("%s" "ERROR(%d): I-cache INSN4[%016llx] INSN5[%016llx] INSN6[%016llx] INSN7[%016llx]\n",
               (recoverable ? KERN_WARNING : KERN_CRIT), smp_processor_id(),
               info->icache_data[4],
               info->icache_data[5],
               info->icache_data[6],
               info->icache_data[7]);
-       printk("%s" "ERROR(%d): E-cache idx[%x] tag[%016lx]\n",
+       printk("%s" "ERROR(%d): E-cache idx[%x] tag[%016llx]\n",
               (recoverable ? KERN_WARNING : KERN_CRIT), smp_processor_id(),
               (int) info->ecache_index, info->ecache_tag);
-       printk("%s" "ERROR(%d): E-cache data0[%016lx] data1[%016lx] data2[%016lx] data3[%016lx]\n",
+       printk("%s" "ERROR(%d): E-cache data0[%016llx] data1[%016llx] data2[%016llx] data3[%016llx]\n",
               (recoverable ? KERN_WARNING : KERN_CRIT), smp_processor_id(),
               info->ecache_data[0],
               info->ecache_data[1],
        int cnt;
 
        printk("%s: Reporting on cpu %d\n", pfx, cpu);
-       printk("%s: err_handle[%lx] err_stick[%lx] err_type[%08x:%s]\n",
+       printk("%s: err_handle[%llx] err_stick[%llx] err_type[%08x:%s]\n",
               pfx,
               ent->err_handle, ent->err_stick,
               ent->err_type,
                "privileged" : ""),
               ((ent->err_attrs & SUN4V_ERR_ATTRS_RES_QUEUE_FULL) ?
                "queue-full" : ""));
-       printk("%s: err_raddr[%016lx] err_size[%u] err_cpu[%u]\n",
+       printk("%s: err_raddr[%016llx] err_size[%u] err_cpu[%u]\n",
               pfx,
               ent->err_raddr, ent->err_size, ent->err_cpu);
 
 
                dev_set_name(&vdev->dev, "%s", bus_id_name);
                vdev->dev_no = ~(u64)0;
        } else if (!cfg_handle) {
-               dev_set_name(&vdev->dev, "%s-%lu", bus_id_name, *id);
+               dev_set_name(&vdev->dev, "%s-%llu", bus_id_name, *id);
                vdev->dev_no = *id;
        } else {
-               dev_set_name(&vdev->dev, "%s-%lu-%lu", bus_id_name,
+               dev_set_name(&vdev->dev, "%s-%llu-%llu", bus_id_name,
                             *cfg_handle, *id);
                vdev->dev_no = *cfg_handle;
        }
 
        return -1;
 }
 
-static unsigned long nid_range(unsigned long start, unsigned long end,
-                              int *nid)
+static unsigned long long nid_range(unsigned long long start,
+                                   unsigned long long end, int *nid)
 {
        *nid = find_node(start);
        start += PAGE_SIZE;
        return start;
 }
 #else
-static unsigned long nid_range(unsigned long start, unsigned long end,
-                              int *nid)
+static unsigned long long nid_range(unsigned long long start,
+                                   unsigned long long end, int *nid)
 {
        *nid = 0;
        return end;
                val = mdesc_get_property(md, node, "address-mask", NULL);
                m->mask = *val;
 
-               numadbg("MLGROUP[%d]: node[%lx] latency[%lx] "
-                       "match[%lx] mask[%lx]\n",
+               numadbg("MLGROUP[%d]: node[%llx] latency[%llx] "
+                       "match[%llx] mask[%llx]\n",
                        count - 1, m->node, m->latency, m->match, m->mask);
        }
 
                                         "address-congruence-offset", NULL);
                m->offset = *val;
 
-               numadbg("MBLOCK[%d]: base[%lx] size[%lx] offset[%lx]\n",
+               numadbg("MBLOCK[%d]: base[%llx] size[%llx] offset[%llx]\n",
                        count - 1, m->base, m->size, m->offset);
        }
 
        n->mask = candidate->mask;
        n->val = candidate->match;
 
-       numadbg("NUMA NODE[%d]: mask[%lx] val[%lx] (latency[%lx])\n",
+       numadbg("NUMA NODE[%d]: mask[%lx] val[%lx] (latency[%llx])\n",
                index, n->mask, n->val, candidate->latency);
 
        return 0;