Merge branch 'merge' of git://git.kernel.org/pub/scm/linux/kernel/git/benh/powerpc

* 'merge' of git://git.kernel.org/pub/scm/linux/kernel/git/benh/powerpc:
  serial: Add 16850 uart type support to OF uart driver
  hvc_console: Remove tty->low_latency
  powerpc: Get the number of SLBs from "slb-size" property
  powerpc: is_hugepage_only_range() must account for both 4kB and 64kB slices
  powerpc/ps3: printing fixups for l64 to ll64 conversion drivers/video
  powerpc/ps3: Printing fixups for l64 to ll64 conversion drivers/scsi
  powerpc/ps3: Printing fixups for l64 to ll64 conversion drivers/ps3
  powerpc/ps3: Printing fixups for l64 to ll64 conversion sound/ppc
  powerpc/ps3: Printing fixups for l64 to ll64 conversion drivers/char
  powerpc/ps3: Printing fixups for l64 to ll64 conversion drivers/block
  powerpc/ps3: Printing fixups for l64 to ll64 conversion arch/powerpc
  powerpc/ps3: ps3_repository_read_mm_info() takes u64 * arguments
  powerpc/ps3: clear_bit()/set_bit() operate on unsigned longs
  powerpc/ps3: The lv1_ routines have u64 parameters
  powerpc/ps3: Use dma_addr_t down through the stack
  powerpc/ps3: set_dabr() takes an unsigned long
  powerpc: Cleanup from l64 to ll64 change drivers/scsi

diff --git a/arch/powerpc/include/asm/ps3.h b/arch/powerpc/include/asm/ps3.h
index eead5c67197abb3478d4a3e5dd25815949e9e488..67f1812698d2703e02cad2c561fd1d0e6c6d84b2 100644 (file)
--- a/arch/powerpc/include/asm/ps3.h
+++ b/arch/powerpc/include/asm/ps3.h
@@ -103,10 +103,10 @@ struct ps3_dma_region_ops {
        int (*map)(struct ps3_dma_region *,
                   unsigned long virt_addr,
                   unsigned long len,
-                  unsigned long *bus_addr,
+                  dma_addr_t *bus_addr,
                   u64 iopte_pp);
        int (*unmap)(struct ps3_dma_region *,
-                    unsigned long bus_addr,
+                    dma_addr_t bus_addr,
                     unsigned long len);
 };
 /**
@@ -124,9 +124,9 @@ int ps3_dma_region_init(struct ps3_system_bus_device *dev,
 int ps3_dma_region_create(struct ps3_dma_region *r);
 int ps3_dma_region_free(struct ps3_dma_region *r);
 int ps3_dma_map(struct ps3_dma_region *r, unsigned long virt_addr,
-       unsigned long len, unsigned long *bus_addr,
+       unsigned long len, dma_addr_t *bus_addr,
        u64 iopte_pp);
-int ps3_dma_unmap(struct ps3_dma_region *r, unsigned long bus_addr,
+int ps3_dma_unmap(struct ps3_dma_region *r, dma_addr_t bus_addr,
        unsigned long len);
 
 /* mmio routines */

diff --git a/arch/powerpc/kernel/prom.c b/arch/powerpc/kernel/prom.c
index c09cffafb6ee5f8f2697fd4f55a1cf991f5db9cf..f00f83109ab309bbe38cca6a989155795413d4a7 100644 (file)
--- a/arch/powerpc/kernel/prom.c
+++ b/arch/powerpc/kernel/prom.c
@@ -590,6 +590,11 @@ static void __init check_cpu_slb_size(unsigned long node)
 {
        u32 *slb_size_ptr;
 
+       slb_size_ptr = of_get_flat_dt_prop(node, "slb-size", NULL);
+       if (slb_size_ptr != NULL) {
+               mmu_slb_size = *slb_size_ptr;
+               return;
+       }
        slb_size_ptr = of_get_flat_dt_prop(node, "ibm,slb-size", NULL);
        if (slb_size_ptr != NULL) {
                mmu_slb_size = *slb_size_ptr;

diff --git a/arch/powerpc/mm/slice.c b/arch/powerpc/mm/slice.c
index db44e02e045b2b7a058844ac5dfdfacfdbb4fd01..ba5194817f8ae67e275c49b66f4c86631c1013d4 100644 (file)
--- a/arch/powerpc/mm/slice.c
+++ b/arch/powerpc/mm/slice.c
@@ -710,9 +710,18 @@ int is_hugepage_only_range(struct mm_struct *mm, unsigned long addr,
                           unsigned long len)
 {
        struct slice_mask mask, available;
+       unsigned int psize = mm->context.user_psize;
 
        mask = slice_range_to_mask(addr, len);
-       available = slice_mask_for_size(mm, mm->context.user_psize);
+       available = slice_mask_for_size(mm, psize);
+#ifdef CONFIG_PPC_64K_PAGES
+       /* We need to account for 4k slices too */
+       if (psize == MMU_PAGE_64K) {
+               struct slice_mask compat_mask;
+               compat_mask = slice_mask_for_size(mm, MMU_PAGE_4K);
+               or_mask(available, compat_mask);
+       }
+#endif
 
 #if 0 /* too verbose */
        slice_dbg("is_hugepage_only_range(mm=%p, addr=%lx, len=%lx)\n",

diff --git a/arch/powerpc/platforms/ps3/device-init.c b/arch/powerpc/platforms/ps3/device-init.c
index ca71a12b764c3cdbf2b3834aac3354212301e262..bb028f165fb3d0008533d2e55b3eddbec898f076 100644 (file)
--- a/arch/powerpc/platforms/ps3/device-init.c
+++ b/arch/powerpc/platforms/ps3/device-init.c
@@ -82,7 +82,7 @@ static int __init ps3_register_lpm_devices(void)
                goto fail_rights;
        }
 
-       pr_debug("%s:%d: pu_id %lu, rights %lu(%lxh)\n",
+       pr_debug("%s:%d: pu_id %llu, rights %llu(%llxh)\n",
                __func__, __LINE__, dev->lpm.pu_id, dev->lpm.rights,
                dev->lpm.rights);
 
@@ -348,7 +348,7 @@ static int ps3_setup_storage_dev(const struct ps3_repository_device *repo,
                return -ENODEV;
        }
 
-       pr_debug("%s:%u: (%u:%u:%u): port %lu blk_size %lu num_blocks %lu "
+       pr_debug("%s:%u: (%u:%u:%u): port %llu blk_size %llu num_blocks %llu "
                 "num_regions %u\n", __func__, __LINE__, repo->bus_index,
                 repo->dev_index, repo->dev_type, port, blk_size, num_blocks,
                 num_regions);
@@ -394,7 +394,7 @@ static int ps3_setup_storage_dev(const struct ps3_repository_device *repo,
                        result = -ENODEV;
                        goto fail_read_region;
                }
-               pr_debug("%s:%u: region %u: id %u start %lu size %lu\n",
+               pr_debug("%s:%u: region %u: id %u start %llu size %llu\n",
                         __func__, __LINE__, i, id, start, size);
 
                p->regions[i].id = id;
@@ -662,13 +662,13 @@ static void ps3_find_and_add_device(u64 bus_id, u64 dev_id)
                if (rem)
                        break;
        }
-       pr_warning("%s:%u: device %lu:%lu not found\n", __func__, __LINE__,
+       pr_warning("%s:%u: device %llu:%llu not found\n", __func__, __LINE__,
                   bus_id, dev_id);
        return;
 
 found:
        if (retries)
-               pr_debug("%s:%u: device %lu:%lu found after %u retries\n",
+               pr_debug("%s:%u: device %llu:%llu found after %u retries\n",
                         __func__, __LINE__, bus_id, dev_id, retries);
 
        ps3_setup_dynamic_device(&repo);
@@ -715,14 +715,14 @@ static irqreturn_t ps3_notification_interrupt(int irq, void *data)
        res = lv1_storage_get_async_status(PS3_NOTIFICATION_DEV_ID, &tag,
                                           &status);
        if (tag != dev->tag)
-               pr_err("%s:%u: tag mismatch, got %lx, expected %lx\n",
+               pr_err("%s:%u: tag mismatch, got %llx, expected %llx\n",
                       __func__, __LINE__, tag, dev->tag);
 
        if (res) {
-               pr_err("%s:%u: res %d status 0x%lx\n", __func__, __LINE__, res,
+               pr_err("%s:%u: res %d status 0x%llx\n", __func__, __LINE__, res,
                       status);
        } else {
-               pr_debug("%s:%u: completed, status 0x%lx\n", __func__,
+               pr_debug("%s:%u: completed, status 0x%llx\n", __func__,
                         __LINE__, status);
                dev->lv1_status = status;
                complete(&dev->done);
@@ -761,7 +761,7 @@ static int ps3_notification_read_write(struct ps3_notification_device *dev,
        }
 
        if (dev->lv1_status) {
-               pr_err("%s:%u: %s not completed, status 0x%lx\n", __func__,
+               pr_err("%s:%u: %s not completed, status 0x%llx\n", __func__,
                       __LINE__, op, dev->lv1_status);
                return -EIO;
        }
@@ -850,16 +850,16 @@ static int ps3_probe_thread(void *data)
                if (res)
                        break;
 
-               pr_debug("%s:%u: notify event type 0x%lx bus id %lu dev id %lu"
-                        " type %lu port %lu\n", __func__, __LINE__,
+               pr_debug("%s:%u: notify event type 0x%llx bus id %llu dev id %llu"
+                        " type %llu port %llu\n", __func__, __LINE__,
                         notify_event->event_type, notify_event->bus_id,
                         notify_event->dev_id, notify_event->dev_type,
                         notify_event->dev_port);
 
                if (notify_event->event_type != notify_region_probe ||
                    notify_event->bus_id != dev.sbd.bus_id) {
-                       pr_warning("%s:%u: bad notify_event: event %lu, "
-                                  "dev_id %lu, dev_type %lu\n",
+                       pr_warning("%s:%u: bad notify_event: event %llu, "
+                                  "dev_id %llu, dev_type %llu\n",
                                   __func__, __LINE__, notify_event->event_type,
                                   notify_event->dev_id,
                                   notify_event->dev_type);

diff --git a/arch/powerpc/platforms/ps3/htab.c b/arch/powerpc/platforms/ps3/htab.c
index 6eb1d4d182c90653b840e0edfe7294d698150c5f..1e8a1e39dfe816abc4e97cd1c33f12463edaf267 100644 (file)
--- a/arch/powerpc/platforms/ps3/htab.c
+++ b/arch/powerpc/platforms/ps3/htab.c
@@ -75,7 +75,7 @@ static long ps3_hpte_insert(unsigned long hpte_group, unsigned long va,
 
        if (result) {
                /* all entries bolted !*/
-               pr_info("%s:result=%d va=%lx pa=%lx ix=%lx v=%lx r=%lx\n",
+               pr_info("%s:result=%d va=%lx pa=%lx ix=%lx v=%llx r=%llx\n",
                        __func__, result, va, pa, hpte_group, hpte_v, hpte_r);
                BUG();
        }

diff --git a/arch/powerpc/platforms/ps3/interrupt.c b/arch/powerpc/platforms/ps3/interrupt.c
index e59634f7af9637d29bca47505508bb30cf624953..8ec5ccf76b19e02f7e14385cf757ab558ba9662c 100644 (file)
--- a/arch/powerpc/platforms/ps3/interrupt.c
+++ b/arch/powerpc/platforms/ps3/interrupt.c
@@ -60,6 +60,8 @@
  * gives a usable range of plug values of  {NUM_ISA_INTERRUPTS..63}.  Note
  * that there is no constraint on how many in this set an individual thread
  * can acquire.
+ *
+ * The mask is declared as unsigned long so we can use set/clear_bit on it.
  */
 
 #define PS3_BMP_MINALIGN 64
@@ -68,7 +70,7 @@ struct ps3_bmp {
        struct {
                u64 status;
                u64 unused_1[3];
-               u64 mask;
+               unsigned long mask;
                u64 unused_2[3];
        };
        u64 ipi_debug_brk_mask;
@@ -102,7 +104,7 @@ static void ps3_chip_mask(unsigned int virq)
        struct ps3_private *pd = get_irq_chip_data(virq);
        unsigned long flags;
 
-       pr_debug("%s:%d: thread_id %lu, virq %d\n", __func__, __LINE__,
+       pr_debug("%s:%d: thread_id %llu, virq %d\n", __func__, __LINE__,
                pd->thread_id, virq);
 
        local_irq_save(flags);
@@ -123,7 +125,7 @@ static void ps3_chip_unmask(unsigned int virq)
        struct ps3_private *pd = get_irq_chip_data(virq);
        unsigned long flags;
 
-       pr_debug("%s:%d: thread_id %lu, virq %d\n", __func__, __LINE__,
+       pr_debug("%s:%d: thread_id %llu, virq %d\n", __func__, __LINE__,
                pd->thread_id, virq);
 
        local_irq_save(flags);
@@ -221,7 +223,7 @@ static int ps3_virq_destroy(unsigned int virq)
 {
        const struct ps3_private *pd = get_irq_chip_data(virq);
 
-       pr_debug("%s:%d: ppe_id %lu, thread_id %lu, virq %u\n", __func__,
+       pr_debug("%s:%d: ppe_id %llu, thread_id %llu, virq %u\n", __func__,
                __LINE__, pd->ppe_id, pd->thread_id, virq);
 
        set_irq_chip_data(virq, NULL);
@@ -291,7 +293,7 @@ int ps3_irq_plug_destroy(unsigned int virq)
        int result;
        const struct ps3_private *pd = get_irq_chip_data(virq);
 
-       pr_debug("%s:%d: ppe_id %lu, thread_id %lu, virq %u\n", __func__,
+       pr_debug("%s:%d: ppe_id %llu, thread_id %llu, virq %u\n", __func__,
                __LINE__, pd->ppe_id, pd->thread_id, virq);
 
        ps3_chip_mask(virq);
@@ -322,7 +324,7 @@ EXPORT_SYMBOL_GPL(ps3_irq_plug_destroy);
 int ps3_event_receive_port_setup(enum ps3_cpu_binding cpu, unsigned int *virq)
 {
        int result;
-       unsigned long outlet;
+       u64 outlet;
 
        result = lv1_construct_event_receive_port(&outlet);
 
@@ -468,7 +470,7 @@ int ps3_io_irq_setup(enum ps3_cpu_binding cpu, unsigned int interrupt_id,
        unsigned int *virq)
 {
        int result;
-       unsigned long outlet;
+       u64 outlet;
 
        result = lv1_construct_io_irq_outlet(interrupt_id, &outlet);
 
@@ -525,7 +527,7 @@ int ps3_vuart_irq_setup(enum ps3_cpu_binding cpu, void* virt_addr_bmp,
        unsigned int *virq)
 {
        int result;
-       unsigned long outlet;
+       u64 outlet;
        u64 lpar_addr;
 
        BUG_ON(!is_kernel_addr((u64)virt_addr_bmp));
@@ -581,7 +583,7 @@ int ps3_spe_irq_setup(enum ps3_cpu_binding cpu, unsigned long spe_id,
        unsigned int class, unsigned int *virq)
 {
        int result;
-       unsigned long outlet;
+       u64 outlet;
 
        BUG_ON(class > 2);
 
@@ -691,7 +693,7 @@ void __init ps3_register_ipi_debug_brk(unsigned int cpu, unsigned int virq)
 
        pd->bmp.ipi_debug_brk_mask = 0x8000000000000000UL >> virq;
 
-       pr_debug("%s:%d: cpu %u, virq %u, mask %lxh\n", __func__, __LINE__,
+       pr_debug("%s:%d: cpu %u, virq %u, mask %llxh\n", __func__, __LINE__,
                cpu, virq, pd->bmp.ipi_debug_brk_mask);
 }
 
@@ -710,7 +712,7 @@ static unsigned int ps3_get_irq(void)
        plug &= 0x3f;
 
        if (unlikely(plug == NO_IRQ)) {
-               pr_debug("%s:%d: no plug found: thread_id %lu\n", __func__,
+               pr_debug("%s:%d: no plug found: thread_id %llu\n", __func__,
                        __LINE__, pd->thread_id);
                dump_bmp(&per_cpu(ps3_private, 0));
                dump_bmp(&per_cpu(ps3_private, 1));
@@ -745,7 +747,7 @@ void __init ps3_init_IRQ(void)
                pd->thread_id = get_hard_smp_processor_id(cpu);
                spin_lock_init(&pd->bmp.lock);
 
-               pr_debug("%s:%d: ppe_id %lu, thread_id %lu, bmp %lxh\n",
+               pr_debug("%s:%d: ppe_id %llu, thread_id %llu, bmp %lxh\n",
                        __func__, __LINE__, pd->ppe_id, pd->thread_id,
                        ps3_mm_phys_to_lpar(__pa(&pd->bmp)));
 
@@ -770,6 +772,6 @@ void ps3_shutdown_IRQ(int cpu)
        lv1_get_logical_ppe_id(&ppe_id);
        result = lv1_configure_irq_state_bitmap(ppe_id, thread_id, 0);
 
-       DBG("%s:%d: lv1_configure_irq_state_bitmap (%lu:%lu/%d) %s\n", __func__,
+       DBG("%s:%d: lv1_configure_irq_state_bitmap (%llu:%llu/%d) %s\n", __func__,
                __LINE__, ppe_id, thread_id, cpu, ps3_result(result));
 }

diff --git a/arch/powerpc/platforms/ps3/mm.c b/arch/powerpc/platforms/ps3/mm.c
index a4d49dd9e8a9d7f101fe42c8f5f67bda91647392..67de6bf3db3d243a6d542dec9b9028d7f9fcf111 100644 (file)
--- a/arch/powerpc/platforms/ps3/mm.c
+++ b/arch/powerpc/platforms/ps3/mm.c
@@ -79,8 +79,8 @@ enum {
  */
 
 struct mem_region {
-       unsigned long base;
-       unsigned long size;
+       u64 base;
+       u64 size;
        unsigned long offset;
 };
 
@@ -103,9 +103,9 @@ struct mem_region {
  */
 
 struct map {
-       unsigned long total;
-       unsigned long vas_id;
-       unsigned long htab_size;
+       u64 total;
+       u64 vas_id;
+       u64 htab_size;
        struct mem_region rm;
        struct mem_region r1;
 };
@@ -114,13 +114,13 @@ struct map {
 static void __maybe_unused _debug_dump_map(const struct map *m,
        const char *func, int line)
 {
-       DBG("%s:%d: map.total     = %lxh\n", func, line, m->total);
-       DBG("%s:%d: map.rm.size   = %lxh\n", func, line, m->rm.size);
-       DBG("%s:%d: map.vas_id    = %lu\n", func, line, m->vas_id);
-       DBG("%s:%d: map.htab_size = %lxh\n", func, line, m->htab_size);
-       DBG("%s:%d: map.r1.base   = %lxh\n", func, line, m->r1.base);
+       DBG("%s:%d: map.total     = %llxh\n", func, line, m->total);
+       DBG("%s:%d: map.rm.size   = %llxh\n", func, line, m->rm.size);
+       DBG("%s:%d: map.vas_id    = %llu\n", func, line, m->vas_id);
+       DBG("%s:%d: map.htab_size = %llxh\n", func, line, m->htab_size);
+       DBG("%s:%d: map.r1.base   = %llxh\n", func, line, m->r1.base);
        DBG("%s:%d: map.r1.offset = %lxh\n", func, line, m->r1.offset);
-       DBG("%s:%d: map.r1.size   = %lxh\n", func, line, m->r1.size);
+       DBG("%s:%d: map.r1.size   = %llxh\n", func, line, m->r1.size);
 }
 
 static struct map map;
@@ -146,11 +146,11 @@ EXPORT_SYMBOL(ps3_mm_phys_to_lpar);
 void __init ps3_mm_vas_create(unsigned long* htab_size)
 {
        int result;
-       unsigned long start_address;
-       unsigned long size;
-       unsigned long access_right;
-       unsigned long max_page_size;
-       unsigned long flags;
+       u64 start_address;
+       u64 size;
+       u64 access_right;
+       u64 max_page_size;
+       u64 flags;
 
        result = lv1_query_logical_partition_address_region_info(0,
                &start_address, &size, &access_right, &max_page_size,
@@ -164,7 +164,7 @@ void __init ps3_mm_vas_create(unsigned long* htab_size)
        }
 
        if (max_page_size < PAGE_SHIFT_16M) {
-               DBG("%s:%d: bad max_page_size %lxh\n", __func__, __LINE__,
+               DBG("%s:%d: bad max_page_size %llxh\n", __func__, __LINE__,
                        max_page_size);
                goto fail;
        }
@@ -208,7 +208,7 @@ void ps3_mm_vas_destroy(void)
 {
        int result;
 
-       DBG("%s:%d: map.vas_id    = %lu\n", __func__, __LINE__, map.vas_id);
+       DBG("%s:%d: map.vas_id    = %llu\n", __func__, __LINE__, map.vas_id);
 
        if (map.vas_id) {
                result = lv1_select_virtual_address_space(0);
@@ -235,15 +235,14 @@ void ps3_mm_vas_destroy(void)
 static int ps3_mm_region_create(struct mem_region *r, unsigned long size)
 {
        int result;
-       unsigned long muid;
+       u64 muid;
 
        r->size = _ALIGN_DOWN(size, 1 << PAGE_SHIFT_16M);
 
        DBG("%s:%d requested  %lxh\n", __func__, __LINE__, size);
-       DBG("%s:%d actual     %lxh\n", __func__, __LINE__, r->size);
-       DBG("%s:%d difference %lxh (%luMB)\n", __func__, __LINE__,
-               (unsigned long)(size - r->size),
-               (size - r->size) / 1024 / 1024);
+       DBG("%s:%d actual     %llxh\n", __func__, __LINE__, r->size);
+       DBG("%s:%d difference %llxh (%lluMB)\n", __func__, __LINE__,
+               size - r->size, (size - r->size) / 1024 / 1024);
 
        if (r->size == 0) {
                DBG("%s:%d: size == 0\n", __func__, __LINE__);
@@ -277,7 +276,7 @@ static void ps3_mm_region_destroy(struct mem_region *r)
 {
        int result;
 
-       DBG("%s:%d: r->base = %lxh\n", __func__, __LINE__, r->base);
+       DBG("%s:%d: r->base = %llxh\n", __func__, __LINE__, r->base);
        if (r->base) {
                result = lv1_release_memory(r->base);
                BUG_ON(result);
@@ -355,7 +354,7 @@ static unsigned long dma_sb_lpar_to_bus(struct ps3_dma_region *r,
 static void  __maybe_unused _dma_dump_region(const struct ps3_dma_region *r,
        const char *func, int line)
 {
-       DBG("%s:%d: dev        %lu:%lu\n", func, line, r->dev->bus_id,
+       DBG("%s:%d: dev        %llu:%llu\n", func, line, r->dev->bus_id,
                r->dev->dev_id);
        DBG("%s:%d: page_size  %u\n", func, line, r->page_size);
        DBG("%s:%d: bus_addr   %lxh\n", func, line, r->bus_addr);
@@ -390,7 +389,7 @@ struct dma_chunk {
 static void _dma_dump_chunk (const struct dma_chunk* c, const char* func,
        int line)
 {
-       DBG("%s:%d: r.dev        %lu:%lu\n", func, line,
+       DBG("%s:%d: r.dev        %llu:%llu\n", func, line,
                c->region->dev->bus_id, c->region->dev->dev_id);
        DBG("%s:%d: r.bus_addr   %lxh\n", func, line, c->region->bus_addr);
        DBG("%s:%d: r.page_size  %u\n", func, line, c->region->page_size);
@@ -596,7 +595,7 @@ static int dma_ioc0_map_pages(struct ps3_dma_region *r, unsigned long phys_addr,
 
        /* build ioptes for the area */
        pages = len >> r->page_size;
-       DBG("%s: pgsize=%#x len=%#lx pages=%#x iopteflag=%#lx\n", __func__,
+       DBG("%s: pgsize=%#x len=%#lx pages=%#x iopteflag=%#llx\n", __func__,
            r->page_size, r->len, pages, iopte_flag);
        for (iopage = 0; iopage < pages; iopage++) {
                offset = (1 << r->page_size) * iopage;
@@ -648,13 +647,14 @@ fail_alloc:
 static int dma_sb_region_create(struct ps3_dma_region *r)
 {
        int result;
+       u64 bus_addr;
 
        DBG(" -> %s:%d:\n", __func__, __LINE__);
 
        BUG_ON(!r);
 
        if (!r->dev->bus_id) {
-               pr_info("%s:%d: %lu:%lu no dma\n", __func__, __LINE__,
+               pr_info("%s:%d: %llu:%llu no dma\n", __func__, __LINE__,
                        r->dev->bus_id, r->dev->dev_id);
                return 0;
        }
@@ -671,7 +671,8 @@ static int dma_sb_region_create(struct ps3_dma_region *r)
 
        result = lv1_allocate_device_dma_region(r->dev->bus_id, r->dev->dev_id,
                roundup_pow_of_two(r->len), r->page_size, r->region_type,
-               &r->bus_addr);
+               &bus_addr);
+       r->bus_addr = bus_addr;
 
        if (result) {
                DBG("%s:%d: lv1_allocate_device_dma_region failed: %s\n",
@@ -685,6 +686,7 @@ static int dma_sb_region_create(struct ps3_dma_region *r)
 static int dma_ioc0_region_create(struct ps3_dma_region *r)
 {
        int result;
+       u64 bus_addr;
 
        INIT_LIST_HEAD(&r->chunk_list.head);
        spin_lock_init(&r->chunk_list.lock);
@@ -692,7 +694,8 @@ static int dma_ioc0_region_create(struct ps3_dma_region *r)
        result = lv1_allocate_io_segment(0,
                                         r->len,
                                         r->page_size,
-                                        &r->bus_addr);
+                                        &bus_addr);
+       r->bus_addr = bus_addr;
        if (result) {
                DBG("%s:%d: lv1_allocate_io_segment failed: %s\n",
                        __func__, __LINE__, ps3_result(result));
@@ -720,7 +723,7 @@ static int dma_sb_region_free(struct ps3_dma_region *r)
        BUG_ON(!r);
 
        if (!r->dev->bus_id) {
-               pr_info("%s:%d: %lu:%lu no dma\n", __func__, __LINE__,
+               pr_info("%s:%d: %llu:%llu no dma\n", __func__, __LINE__,
                        r->dev->bus_id, r->dev->dev_id);
                return 0;
        }
@@ -777,7 +780,7 @@ static int dma_ioc0_region_free(struct ps3_dma_region *r)
  */
 
 static int dma_sb_map_area(struct ps3_dma_region *r, unsigned long virt_addr,
-          unsigned long len, unsigned long *bus_addr,
+          unsigned long len, dma_addr_t *bus_addr,
           u64 iopte_flag)
 {
        int result;
@@ -800,7 +803,7 @@ static int dma_sb_map_area(struct ps3_dma_region *r, unsigned long virt_addr,
                DBG("%s:%d lpar_addr %lxh\n", __func__, __LINE__,
                        lpar_addr);
                DBG("%s:%d len       %lxh\n", __func__, __LINE__, len);
-               DBG("%s:%d bus_addr  %lxh (%lxh)\n", __func__, __LINE__,
+               DBG("%s:%d bus_addr  %llxh (%lxh)\n", __func__, __LINE__,
                *bus_addr, len);
        }
 
@@ -832,7 +835,7 @@ static int dma_sb_map_area(struct ps3_dma_region *r, unsigned long virt_addr,
 }
 
 static int dma_ioc0_map_area(struct ps3_dma_region *r, unsigned long virt_addr,
-            unsigned long len, unsigned long *bus_addr,
+            unsigned long len, dma_addr_t *bus_addr,
             u64 iopte_flag)
 {
        int result;
@@ -872,7 +875,7 @@ static int dma_ioc0_map_area(struct ps3_dma_region *r, unsigned long virt_addr,
                return result;
        }
        *bus_addr = c->bus_addr + phys_addr - aligned_phys;
-       DBG("%s: va=%#lx pa=%#lx a_pa=%#lx bus=%#lx\n", __func__,
+       DBG("%s: va=%#lx pa=%#lx a_pa=%#lx bus=%#llx\n", __func__,
            virt_addr, phys_addr, aligned_phys, *bus_addr);
        c->usage_count = 1;
 
@@ -889,7 +892,7 @@ static int dma_ioc0_map_area(struct ps3_dma_region *r, unsigned long virt_addr,
  * This is the common dma unmap routine.
  */
 
-static int dma_sb_unmap_area(struct ps3_dma_region *r, unsigned long bus_addr,
+static int dma_sb_unmap_area(struct ps3_dma_region *r, dma_addr_t bus_addr,
        unsigned long len)
 {
        unsigned long flags;
@@ -903,7 +906,7 @@ static int dma_sb_unmap_area(struct ps3_dma_region *r, unsigned long bus_addr,
                        1 << r->page_size);
                unsigned long aligned_len = _ALIGN_UP(len + bus_addr
                        - aligned_bus, 1 << r->page_size);
-               DBG("%s:%d: not found: bus_addr %lxh\n",
+               DBG("%s:%d: not found: bus_addr %llxh\n",
                        __func__, __LINE__, bus_addr);
                DBG("%s:%d: not found: len %lxh\n",
                        __func__, __LINE__, len);
@@ -926,12 +929,12 @@ static int dma_sb_unmap_area(struct ps3_dma_region *r, unsigned long bus_addr,
 }
 
 static int dma_ioc0_unmap_area(struct ps3_dma_region *r,
-                       unsigned long bus_addr, unsigned long len)
+                       dma_addr_t bus_addr, unsigned long len)
 {
        unsigned long flags;
        struct dma_chunk *c;
 
-       DBG("%s: start a=%#lx l=%#lx\n", __func__, bus_addr, len);
+       DBG("%s: start a=%#llx l=%#lx\n", __func__, bus_addr, len);
        spin_lock_irqsave(&r->chunk_list.lock, flags);
        c = dma_find_chunk(r, bus_addr, len);
 
@@ -941,7 +944,7 @@ static int dma_ioc0_unmap_area(struct ps3_dma_region *r,
                unsigned long aligned_len = _ALIGN_UP(len + bus_addr
                                                      - aligned_bus,
                                                      1 << r->page_size);
-               DBG("%s:%d: not found: bus_addr %lxh\n",
+               DBG("%s:%d: not found: bus_addr %llxh\n",
                    __func__, __LINE__, bus_addr);
                DBG("%s:%d: not found: len %lxh\n",
                    __func__, __LINE__, len);
@@ -975,7 +978,8 @@ static int dma_ioc0_unmap_area(struct ps3_dma_region *r,
 static int dma_sb_region_create_linear(struct ps3_dma_region *r)
 {
        int result;
-       unsigned long virt_addr, len, tmp;
+       unsigned long virt_addr, len;
+       dma_addr_t tmp;
 
        if (r->len > 16*1024*1024) {    /* FIXME: need proper fix */
                /* force 16M dma pages for linear mapping */
@@ -1027,7 +1031,8 @@ static int dma_sb_region_create_linear(struct ps3_dma_region *r)
 static int dma_sb_region_free_linear(struct ps3_dma_region *r)
 {
        int result;
-       unsigned long bus_addr, len, lpar_addr;
+       dma_addr_t bus_addr;
+       unsigned long len, lpar_addr;
 
        if (r->offset < map.rm.size) {
                /* Unmap (part of) 1st RAM chunk */
@@ -1072,7 +1077,7 @@ static int dma_sb_region_free_linear(struct ps3_dma_region *r)
  */
 
 static int dma_sb_map_area_linear(struct ps3_dma_region *r,
-       unsigned long virt_addr, unsigned long len, unsigned long *bus_addr,
+       unsigned long virt_addr, unsigned long len, dma_addr_t *bus_addr,
        u64 iopte_flag)
 {
        unsigned long phys_addr = is_kernel_addr(virt_addr) ? __pa(virt_addr)
@@ -1091,7 +1096,7 @@ static int dma_sb_map_area_linear(struct ps3_dma_region *r,
  */
 
 static int dma_sb_unmap_area_linear(struct ps3_dma_region *r,
-       unsigned long bus_addr, unsigned long len)
+       dma_addr_t bus_addr, unsigned long len)
 {
        return 0;
 };
@@ -1169,13 +1174,13 @@ int ps3_dma_region_free(struct ps3_dma_region *r)
 EXPORT_SYMBOL(ps3_dma_region_free);
 
 int ps3_dma_map(struct ps3_dma_region *r, unsigned long virt_addr,
-       unsigned long len, unsigned long *bus_addr,
+       unsigned long len, dma_addr_t *bus_addr,
        u64 iopte_flag)
 {
        return r->region_ops->map(r, virt_addr, len, bus_addr, iopte_flag);
 }
 
-int ps3_dma_unmap(struct ps3_dma_region *r, unsigned long bus_addr,
+int ps3_dma_unmap(struct ps3_dma_region *r, dma_addr_t bus_addr,
        unsigned long len)
 {
        return r->region_ops->unmap(r, bus_addr, len);

diff --git a/arch/powerpc/platforms/ps3/os-area.c b/arch/powerpc/platforms/ps3/os-area.c
index 1d201782d4e5809190fcf4bb9ff64df5e9074195..e1c83c23b435a2f8032093def6afa1a844d5d1ab 100644 (file)
--- a/arch/powerpc/platforms/ps3/os-area.c
+++ b/arch/powerpc/platforms/ps3/os-area.c
@@ -306,7 +306,7 @@ static void _dump_params(const struct os_area_params *p, const char *func,
 {
        pr_debug("%s:%d: p.boot_flag:       %u\n", func, line, p->boot_flag);
        pr_debug("%s:%d: p.num_params:      %u\n", func, line, p->num_params);
-       pr_debug("%s:%d: p.rtc_diff         %ld\n", func, line, p->rtc_diff);
+       pr_debug("%s:%d: p.rtc_diff         %lld\n", func, line, p->rtc_diff);
        pr_debug("%s:%d: p.av_multi_out     %u\n", func, line, p->av_multi_out);
        pr_debug("%s:%d: p.ctrl_button:     %u\n", func, line, p->ctrl_button);
        pr_debug("%s:%d: p.static_ip_addr:  %u.%u.%u.%u\n", func, line,

diff --git a/arch/powerpc/platforms/ps3/repository.c b/arch/powerpc/platforms/ps3/repository.c
index 22063adeb38be567e844482877251f89cf0d4fe6..5e304c292f68e1e22e3fff9dd3527ae8a5f1bcd1 100644 (file)
--- a/arch/powerpc/platforms/ps3/repository.c
+++ b/arch/powerpc/platforms/ps3/repository.c
@@ -44,7 +44,7 @@ static void _dump_field(const char *hdr, u64 n, const char *func, int line)
                s[i] = (in[i] <= 126 && in[i] >= 32) ? in[i] : '.';
        s[i] = 0;
 
-       pr_debug("%s:%d: %s%016lx : %s\n", func, line, hdr, n, s);
+       pr_debug("%s:%d: %s%016llx : %s\n", func, line, hdr, n, s);
 #endif
 }
 
@@ -70,8 +70,8 @@ static void _dump_node(unsigned int lpar_id, u64 n1, u64 n2, u64 n3, u64 n4,
        _dump_field("n2: ", n2, func, line);
        _dump_field("n3: ", n3, func, line);
        _dump_field("n4: ", n4, func, line);
-       pr_debug("%s:%d: v1: %016lx\n", func, line, v1);
-       pr_debug("%s:%d: v2: %016lx\n", func, line, v2);
+       pr_debug("%s:%d: v1: %016llx\n", func, line, v1);
+       pr_debug("%s:%d: v2: %016llx\n", func, line, v2);
 }
 
 /**
@@ -149,10 +149,10 @@ static int read_node(unsigned int lpar_id, u64 n1, u64 n2, u64 n3, u64 n4,
                *_v2 = v2;
 
        if (v1 && !_v1)
-               pr_debug("%s:%d: warning: discarding non-zero v1: %016lx\n",
+               pr_debug("%s:%d: warning: discarding non-zero v1: %016llx\n",
                        __func__, __LINE__, v1);
        if (v2 && !_v2)
-               pr_debug("%s:%d: warning: discarding non-zero v2: %016lx\n",
+               pr_debug("%s:%d: warning: discarding non-zero v2: %016llx\n",
                        __func__, __LINE__, v2);
 
        return 0;
@@ -327,7 +327,7 @@ int ps3_repository_find_device(struct ps3_repository_device *repo)
                return result;
        }
 
-       pr_debug("%s:%d: bus_type %u, bus_index %u, bus_id %lu, num_dev %u\n",
+       pr_debug("%s:%d: bus_type %u, bus_index %u, bus_id %llu, num_dev %u\n",
                __func__, __LINE__, tmp.bus_type, tmp.bus_index, tmp.bus_id,
                num_dev);
 
@@ -353,7 +353,7 @@ int ps3_repository_find_device(struct ps3_repository_device *repo)
                return result;
        }
 
-       pr_debug("%s:%d: found: dev_type %u, dev_index %u, dev_id %lu\n",
+       pr_debug("%s:%d: found: dev_type %u, dev_index %u, dev_id %llu\n",
                __func__, __LINE__, tmp.dev_type, tmp.dev_index, tmp.dev_id);
 
        *repo = tmp;
@@ -367,7 +367,7 @@ int ps3_repository_find_device_by_id(struct ps3_repository_device *repo,
        struct ps3_repository_device tmp;
        unsigned int num_dev;
 
-       pr_debug(" -> %s:%u: find device by id %lu:%lu\n", __func__, __LINE__,
+       pr_debug(" -> %s:%u: find device by id %llu:%llu\n", __func__, __LINE__,
                 bus_id, dev_id);
 
        for (tmp.bus_index = 0; tmp.bus_index < 10; tmp.bus_index++) {
@@ -382,7 +382,7 @@ int ps3_repository_find_device_by_id(struct ps3_repository_device *repo,
                if (tmp.bus_id == bus_id)
                        goto found_bus;
 
-               pr_debug("%s:%u: skip, bus_id %lu\n", __func__, __LINE__,
+               pr_debug("%s:%u: skip, bus_id %llu\n", __func__, __LINE__,
                         tmp.bus_id);
        }
        pr_debug(" <- %s:%u: bus not found\n", __func__, __LINE__);
@@ -416,7 +416,7 @@ found_bus:
                if (tmp.dev_id == dev_id)
                        goto found_dev;
 
-               pr_debug("%s:%u: skip, dev_id %lu\n", __func__, __LINE__,
+               pr_debug("%s:%u: skip, dev_id %llu\n", __func__, __LINE__,
                         tmp.dev_id);
        }
        pr_debug(" <- %s:%u: dev not found\n", __func__, __LINE__);
@@ -430,7 +430,7 @@ found_dev:
                return result;
        }
 
-       pr_debug(" <- %s:%u: found: type (%u:%u) index (%u:%u) id (%lu:%lu)\n",
+       pr_debug(" <- %s:%u: found: type (%u:%u) index (%u:%u) id (%llu:%llu)\n",
                 __func__, __LINE__, tmp.bus_type, tmp.dev_type, tmp.bus_index,
                 tmp.dev_index, tmp.bus_id, tmp.dev_id);
        *repo = tmp;

diff --git a/arch/powerpc/platforms/ps3/setup.c b/arch/powerpc/platforms/ps3/setup.c
index 35f3e85cf60ea9d79ff873f10090395c791f1c99..3331ccbb8d389c6d76dd4c548beeb3c30d6404b8 100644 (file)
--- a/arch/powerpc/platforms/ps3/setup.c
+++ b/arch/powerpc/platforms/ps3/setup.c
@@ -186,7 +186,7 @@ early_param("ps3flash", early_parse_ps3flash);
 #define prealloc_ps3flash_bounce_buffer()      do { } while (0)
 #endif
 
-static int ps3_set_dabr(u64 dabr)
+static int ps3_set_dabr(unsigned long dabr)
 {
        enum {DABR_USER = 1, DABR_KERNEL = 2,};
 

diff --git a/arch/powerpc/platforms/ps3/spu.c b/arch/powerpc/platforms/ps3/spu.c
index ccae3d446b98e575ffa656f58195ecf21a3877e8..b3c6a993f9f3bc0d16a415391c631d988b887ef2 100644 (file)
--- a/arch/powerpc/platforms/ps3/spu.c
+++ b/arch/powerpc/platforms/ps3/spu.c
@@ -149,7 +149,7 @@ EXPORT_SYMBOL_GPL(ps3_get_spe_id);
 
 static unsigned long get_vas_id(void)
 {
-       unsigned long id;
+       u64 id;
 
        lv1_get_logical_ppe_id(&id);
        lv1_get_virtual_address_space_id_of_ppe(id, &id);
@@ -160,14 +160,18 @@ static unsigned long get_vas_id(void)
 static int __init construct_spu(struct spu *spu)
 {
        int result;
-       unsigned long unused;
+       u64 unused;
+       u64 problem_phys;
+       u64 local_store_phys;
 
        result = lv1_construct_logical_spe(PAGE_SHIFT, PAGE_SHIFT, PAGE_SHIFT,
                PAGE_SHIFT, PAGE_SHIFT, get_vas_id(), SPE_TYPE_LOGICAL,
-               &spu_pdata(spu)->priv2_addr, &spu->problem_phys,
-               &spu->local_store_phys, &unused,
+               &spu_pdata(spu)->priv2_addr, &problem_phys,
+               &local_store_phys, &unused,
                &spu_pdata(spu)->shadow_addr,
                &spu_pdata(spu)->spe_id);
+       spu->problem_phys = problem_phys;
+       spu->local_store_phys = local_store_phys;
 
        if (result) {
                pr_debug("%s:%d: lv1_construct_logical_spe failed: %s\n",

diff --git a/arch/powerpc/platforms/ps3/system-bus.c b/arch/powerpc/platforms/ps3/system-bus.c
index ee0d22911621751ebecfb1d584f10004a4033b53..58311a867851affc29310d3557dd5410350983ff 100644 (file)
--- a/arch/powerpc/platforms/ps3/system-bus.c
+++ b/arch/powerpc/platforms/ps3/system-bus.c
@@ -182,7 +182,7 @@ int ps3_open_hv_device(struct ps3_system_bus_device *dev)
        case PS3_MATCH_ID_SYSTEM_MANAGER:
                pr_debug("%s:%d: unsupported match_id: %u\n", __func__,
                        __LINE__, dev->match_id);
-               pr_debug("%s:%d: bus_id: %lu\n", __func__, __LINE__,
+               pr_debug("%s:%d: bus_id: %llu\n", __func__, __LINE__,
                        dev->bus_id);
                BUG();
                return -EINVAL;
@@ -220,7 +220,7 @@ int ps3_close_hv_device(struct ps3_system_bus_device *dev)
        case PS3_MATCH_ID_SYSTEM_MANAGER:
                pr_debug("%s:%d: unsupported match_id: %u\n", __func__,
                        __LINE__, dev->match_id);
-               pr_debug("%s:%d: bus_id: %lu\n", __func__, __LINE__,
+               pr_debug("%s:%d: bus_id: %llu\n", __func__, __LINE__,
                        dev->bus_id);
                BUG();
                return -EINVAL;
@@ -240,7 +240,7 @@ EXPORT_SYMBOL_GPL(ps3_close_hv_device);
 static void _dump_mmio_region(const struct ps3_mmio_region* r,
        const char* func, int line)
 {
-       pr_debug("%s:%d: dev       %lu:%lu\n", func, line, r->dev->bus_id,
+       pr_debug("%s:%d: dev       %llu:%llu\n", func, line, r->dev->bus_id,
                r->dev->dev_id);
        pr_debug("%s:%d: bus_addr  %lxh\n", func, line, r->bus_addr);
        pr_debug("%s:%d: len       %lxh\n", func, line, r->len);
@@ -250,9 +250,11 @@ static void _dump_mmio_region(const struct ps3_mmio_region* r,
 static int ps3_sb_mmio_region_create(struct ps3_mmio_region *r)
 {
        int result;
+       u64 lpar_addr;
 
        result = lv1_map_device_mmio_region(r->dev->bus_id, r->dev->dev_id,
-               r->bus_addr, r->len, r->page_size, &r->lpar_addr);
+               r->bus_addr, r->len, r->page_size, &lpar_addr);
+       r->lpar_addr = lpar_addr;
 
        if (result) {
                pr_debug("%s:%d: lv1_map_device_mmio_region failed: %s\n",
@@ -568,7 +570,7 @@ static dma_addr_t ps3_sb_map_page(struct device *_dev, struct page *page,
 {
        struct ps3_system_bus_device *dev = ps3_dev_to_system_bus_dev(_dev);
        int result;
-       unsigned long bus_addr;
+       dma_addr_t bus_addr;
        void *ptr = page_address(page) + offset;
 
        result = ps3_dma_map(dev->d_region, (unsigned long)ptr, size,
@@ -590,7 +592,7 @@ static dma_addr_t ps3_ioc0_map_page(struct device *_dev, struct page *page,
 {
        struct ps3_system_bus_device *dev = ps3_dev_to_system_bus_dev(_dev);
        int result;
-       unsigned long bus_addr;
+       dma_addr_t bus_addr;
        u64 iopte_flag;
        void *ptr = page_address(page) + offset;
 

diff --git a/drivers/block/ps3disk.c b/drivers/block/ps3disk.c
index 936466f62afd3ad72d4bb4e017f8b9d05a533f5a..bccc42bb9212d7f37086ac86160521f96bc6fea6 100644 (file)
--- a/drivers/block/ps3disk.c
+++ b/drivers/block/ps3disk.c
@@ -141,7 +141,7 @@ static int ps3disk_submit_request_sg(struct ps3_storage_device *dev,
 
        start_sector = req->sector * priv->blocking_factor;
        sectors = req->nr_sectors * priv->blocking_factor;
-       dev_dbg(&dev->sbd.core, "%s:%u: %s %lu sectors starting at %lu\n",
+       dev_dbg(&dev->sbd.core, "%s:%u: %s %llu sectors starting at %llu\n",
                __func__, __LINE__, op, sectors, start_sector);
 
        if (write) {
@@ -178,7 +178,7 @@ static int ps3disk_submit_flush_request(struct ps3_storage_device *dev,
                                              LV1_STORAGE_ATA_HDDOUT, 0, 0, 0,
                                              0, &dev->tag);
        if (res) {
-               dev_err(&dev->sbd.core, "%s:%u: sync cache failed 0x%lx\n",
+               dev_err(&dev->sbd.core, "%s:%u: sync cache failed 0x%llx\n",
                        __func__, __LINE__, res);
                end_request(req, 0);
                return 0;
@@ -238,11 +238,11 @@ static irqreturn_t ps3disk_interrupt(int irq, void *data)
 
        if (tag != dev->tag)
                dev_err(&dev->sbd.core,
-                       "%s:%u: tag mismatch, got %lx, expected %lx\n",
+                       "%s:%u: tag mismatch, got %llx, expected %llx\n",
                        __func__, __LINE__, tag, dev->tag);
 
        if (res) {
-               dev_err(&dev->sbd.core, "%s:%u: res=%d status=0x%lx\n",
+               dev_err(&dev->sbd.core, "%s:%u: res=%d status=0x%llx\n",
                        __func__, __LINE__, res, status);
                return IRQ_HANDLED;
        }
@@ -269,7 +269,7 @@ static irqreturn_t ps3disk_interrupt(int irq, void *data)
                op = read ? "read" : "write";
        }
        if (status) {
-               dev_dbg(&dev->sbd.core, "%s:%u: %s failed 0x%lx\n", __func__,
+               dev_dbg(&dev->sbd.core, "%s:%u: %s failed 0x%llx\n", __func__,
                        __LINE__, op, status);
                error = -EIO;
        } else {
@@ -297,7 +297,7 @@ static int ps3disk_sync_cache(struct ps3_storage_device *dev)
 
        res = ps3stor_send_command(dev, LV1_STORAGE_ATA_HDDOUT, 0, 0, 0, 0);
        if (res) {
-               dev_err(&dev->sbd.core, "%s:%u: sync cache failed 0x%lx\n",
+               dev_err(&dev->sbd.core, "%s:%u: sync cache failed 0x%llx\n",
                        __func__, __LINE__, res);
                return -EIO;
        }
@@ -388,7 +388,7 @@ static int ps3disk_identify(struct ps3_storage_device *dev)
                                   sizeof(ata_cmnd), ata_cmnd.buffer,
                                   ata_cmnd.arglen);
        if (res) {
-               dev_err(&dev->sbd.core, "%s:%u: identify disk failed 0x%lx\n",
+               dev_err(&dev->sbd.core, "%s:%u: identify disk failed 0x%llx\n",
                        __func__, __LINE__, res);
                return -EIO;
        }
@@ -426,7 +426,7 @@ static int __devinit ps3disk_probe(struct ps3_system_bus_device *_dev)
 
        if (dev->blk_size < 512) {
                dev_err(&dev->sbd.core,
-                       "%s:%u: cannot handle block size %lu\n", __func__,
+                       "%s:%u: cannot handle block size %llu\n", __func__,
                        __LINE__, dev->blk_size);
                return -EINVAL;
        }
@@ -512,7 +512,7 @@ static int __devinit ps3disk_probe(struct ps3_system_bus_device *_dev)
                     dev->regions[dev->region_idx].size*priv->blocking_factor);
 
        dev_info(&dev->sbd.core,
-                "%s is a %s (%lu MiB total, %lu MiB for OtherOS)\n",
+                "%s is a %s (%llu MiB total, %lu MiB for OtherOS)\n",
                 gendisk->disk_name, priv->model, priv->raw_capacity >> 11,
                 get_capacity(gendisk) >> 11);
 

diff --git a/drivers/char/hvc_console.c b/drivers/char/hvc_console.c
index 09676b4e5d8964d77a4cc555cbe30e616c62e7b0..94e7e3c8c05ad3f0720aaae3d6df588eebd2d50b 100644 (file)
--- a/drivers/char/hvc_console.c
+++ b/drivers/char/hvc_console.c
@@ -318,8 +318,6 @@ static int hvc_open(struct tty_struct *tty, struct file * filp)
        } /* else count == 0 */
 
        tty->driver_data = hp;
-       if (!hp->irq_requested)
-               tty->low_latency = 1; /* Makes flushes to ldisc synchronous. */
 
        hp->tty = tty;
 

diff --git a/drivers/char/ps3flash.c b/drivers/char/ps3flash.c
index 79b6f461be75fd829df6fd74ade8de84ab410a20..afbe45676d71c8f064e5102b0e8460dbde0119a3 100644 (file)
--- a/drivers/char/ps3flash.c
+++ b/drivers/char/ps3flash.c
@@ -44,7 +44,7 @@ static ssize_t ps3flash_read_write_sectors(struct ps3_storage_device *dev,
        u64 res = ps3stor_read_write_sectors(dev, lpar, start_sector, sectors,
                                             write);
        if (res) {
-               dev_err(&dev->sbd.core, "%s:%u: %s failed 0x%lx\n", __func__,
+               dev_err(&dev->sbd.core, "%s:%u: %s failed 0x%llx\n", __func__,
                        __LINE__, write ? "write" : "read", res);
                return -EIO;
        }
@@ -59,7 +59,7 @@ static ssize_t ps3flash_read_sectors(struct ps3_storage_device *dev,
 
        max_sectors = dev->bounce_size / dev->blk_size;
        if (sectors > max_sectors) {
-               dev_dbg(&dev->sbd.core, "%s:%u Limiting sectors to %lu\n",
+               dev_dbg(&dev->sbd.core, "%s:%u Limiting sectors to %llu\n",
                        __func__, __LINE__, max_sectors);
                sectors = max_sectors;
        }
@@ -144,7 +144,7 @@ static ssize_t ps3flash_read(struct file *file, char __user *buf, size_t count,
                        goto fail;
                }
 
-               n = min(remaining, sectors_read*dev->blk_size-offset);
+               n = min_t(u64, remaining, sectors_read*dev->blk_size-offset);
                dev_dbg(&dev->sbd.core,
                        "%s:%u: copy %lu bytes from 0x%p to user 0x%p\n",
                        __func__, __LINE__, n, dev->bounce_buf+offset, buf);
@@ -225,7 +225,7 @@ static ssize_t ps3flash_write(struct file *file, const char __user *buf,
                if (end_read_sector >= start_read_sector) {
                        /* Merge head and tail */
                        dev_dbg(&dev->sbd.core,
-                               "Merged head and tail: %lu sectors at %lu\n",
+                               "Merged head and tail: %llu sectors at %llu\n",
                                chunk_sectors, start_write_sector);
                        res = ps3flash_read_sectors(dev, start_write_sector,
                                                    chunk_sectors, 0);
@@ -235,7 +235,7 @@ static ssize_t ps3flash_write(struct file *file, const char __user *buf,
                        if (head) {
                                /* Read head */
                                dev_dbg(&dev->sbd.core,
-                                       "head: %lu sectors at %lu\n", head,
+                                       "head: %llu sectors at %llu\n", head,
                                        start_write_sector);
                                res = ps3flash_read_sectors(dev,
                                                            start_write_sector,
@@ -247,7 +247,7 @@ static ssize_t ps3flash_write(struct file *file, const char __user *buf,
                            start_write_sector+chunk_sectors) {
                                /* Read tail */
                                dev_dbg(&dev->sbd.core,
-                                       "tail: %lu sectors at %lu\n", tail,
+                                       "tail: %llu sectors at %llu\n", tail,
                                        start_read_sector);
                                sec_off = start_read_sector-start_write_sector;
                                res = ps3flash_read_sectors(dev,
@@ -258,7 +258,7 @@ static ssize_t ps3flash_write(struct file *file, const char __user *buf,
                        }
                }
 
-               n = min(remaining, dev->bounce_size-offset);
+               n = min_t(u64, remaining, dev->bounce_size-offset);
                dev_dbg(&dev->sbd.core,
                        "%s:%u: copy %lu bytes from user 0x%p to 0x%p\n",
                        __func__, __LINE__, n, buf, dev->bounce_buf+offset);
@@ -299,11 +299,11 @@ static irqreturn_t ps3flash_interrupt(int irq, void *data)
 
        if (tag != dev->tag)
                dev_err(&dev->sbd.core,
-                       "%s:%u: tag mismatch, got %lx, expected %lx\n",
+                       "%s:%u: tag mismatch, got %llx, expected %llx\n",
                        __func__, __LINE__, tag, dev->tag);
 
        if (res) {
-               dev_err(&dev->sbd.core, "%s:%u: res=%d status=0x%lx\n",
+               dev_err(&dev->sbd.core, "%s:%u: res=%d status=0x%llx\n",
                        __func__, __LINE__, res, status);
        } else {
                dev->lv1_status = status;

diff --git a/drivers/ps3/ps3-lpm.c b/drivers/ps3/ps3-lpm.c
index 204158cf7a55eda807715b4c59f0512f2a1f96bb..fe96793e3f080e155abfae2ef804b211f3c0e166 100644 (file)
--- a/drivers/ps3/ps3-lpm.c
+++ b/drivers/ps3/ps3-lpm.c
@@ -732,7 +732,7 @@ static u64 pm_signal_group_to_ps3_lv1_signal_group(u64 group)
        case 8:
                return pm_translate_signal_group_number_on_island8(subgroup);
        default:
-               dev_dbg(sbd_core(), "%s:%u: island not found: %lu\n", __func__,
+               dev_dbg(sbd_core(), "%s:%u: island not found: %llu\n", __func__,
                        __LINE__, group);
                BUG();
                break;
@@ -765,7 +765,7 @@ static int __ps3_set_signal(u64 lv1_signal_group, u64 bus_select,
                                 signal_select, attr1, attr2, attr3);
        if (ret)
                dev_err(sbd_core(),
-                       "%s:%u: error:%d 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx\n",
+                       "%s:%u: error:%d 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx\n",
                        __func__, __LINE__, ret, lv1_signal_group, bus_select,
                        signal_select, attr1, attr2, attr3);
 
@@ -908,7 +908,7 @@ void ps3_disable_pm(u32 cpu)
 
        lpm_priv->tb_count = tmp;
 
-       dev_dbg(sbd_core(), "%s:%u: tb_count %lu (%lxh)\n", __func__, __LINE__,
+       dev_dbg(sbd_core(), "%s:%u: tb_count %llu (%llxh)\n", __func__, __LINE__,
                lpm_priv->tb_count, lpm_priv->tb_count);
 }
 EXPORT_SYMBOL_GPL(ps3_disable_pm);
@@ -938,7 +938,7 @@ int ps3_lpm_copy_tb(unsigned long offset, void *buf, unsigned long count,
        if (offset >= lpm_priv->tb_count)
                return 0;
 
-       count = min(count, lpm_priv->tb_count - offset);
+       count = min_t(u64, count, lpm_priv->tb_count - offset);
 
        while (*bytes_copied < count) {
                const unsigned long request = count - *bytes_copied;
@@ -993,7 +993,7 @@ int ps3_lpm_copy_tb_to_user(unsigned long offset, void __user *buf,
        if (offset >= lpm_priv->tb_count)
                return 0;
 
-       count = min(count, lpm_priv->tb_count - offset);
+       count = min_t(u64, count, lpm_priv->tb_count - offset);
 
        while (*bytes_copied < count) {
                const unsigned long request = count - *bytes_copied;
@@ -1013,7 +1013,7 @@ int ps3_lpm_copy_tb_to_user(unsigned long offset, void __user *buf,
                result = copy_to_user(buf, lpm_priv->tb_cache, tmp);
 
                if (result) {
-                       dev_dbg(sbd_core(), "%s:%u: 0x%lx bytes at 0x%p\n",
+                       dev_dbg(sbd_core(), "%s:%u: 0x%llx bytes at 0x%p\n",
                                __func__, __LINE__, tmp, buf);
                        dev_err(sbd_core(), "%s:%u: copy_to_user failed: %d\n",
                                __func__, __LINE__, result);
@@ -1148,8 +1148,8 @@ int ps3_lpm_open(enum ps3_lpm_tb_type tb_type, void *tb_cache,
        lpm_priv->shadow.group_control = PS3_LPM_SHADOW_REG_INIT;
        lpm_priv->shadow.debug_bus_control = PS3_LPM_SHADOW_REG_INIT;
 
-       dev_dbg(sbd_core(), "%s:%u: lpm_id 0x%lx, outlet_id 0x%lx, "
-               "tb_size 0x%lx\n", __func__, __LINE__, lpm_priv->lpm_id,
+       dev_dbg(sbd_core(), "%s:%u: lpm_id 0x%llx, outlet_id 0x%llx, "
+               "tb_size 0x%llx\n", __func__, __LINE__, lpm_priv->lpm_id,
                lpm_priv->outlet_id, tb_size);
 
        return 0;

diff --git a/drivers/ps3/ps3-vuart.c b/drivers/ps3/ps3-vuart.c
index 90c097a7a47ab5fc7a41b298f3beb968dbadd359..e4ad5ba5d0a3da7b4014c003f7582d9146323a44 100644 (file)
--- a/drivers/ps3/ps3-vuart.c
+++ b/drivers/ps3/ps3-vuart.c
@@ -114,7 +114,7 @@ struct ports_bmp {
 static void __maybe_unused _dump_ports_bmp(
        const struct ports_bmp *bmp, const char *func, int line)
 {
-       pr_debug("%s:%d: ports_bmp: %016lxh\n", func, line, bmp->status);
+       pr_debug("%s:%d: ports_bmp: %016llxh\n", func, line, bmp->status);
 }
 
 #define dump_port_params(_b) _dump_port_params(_b, __func__, __LINE__)
@@ -159,11 +159,13 @@ int ps3_vuart_get_triggers(struct ps3_system_bus_device *dev,
        struct vuart_triggers *trig)
 {
        int result;
-       unsigned long size;
-       unsigned long val;
+       u64 size;
+       u64 val;
+       u64 tx;
 
        result = lv1_get_virtual_uart_param(dev->port_number,
-               PARAM_TX_TRIGGER, &trig->tx);
+               PARAM_TX_TRIGGER, &tx);
+       trig->tx = tx;
 
        if (result) {
                dev_dbg(&dev->core, "%s:%d: tx_trigger failed: %s\n",
@@ -201,7 +203,7 @@ int ps3_vuart_set_triggers(struct ps3_system_bus_device *dev, unsigned int tx,
        unsigned int rx)
 {
        int result;
-       unsigned long size;
+       u64 size;
 
        result = lv1_set_virtual_uart_param(dev->port_number,
                PARAM_TX_TRIGGER, tx);
@@ -248,7 +250,7 @@ static int ps3_vuart_get_rx_bytes_waiting(struct ps3_system_bus_device *dev,
                dev_dbg(&dev->core, "%s:%d: rx_bytes failed: %s\n",
                        __func__, __LINE__, ps3_result(result));
 
-       dev_dbg(&dev->core, "%s:%d: %lxh\n", __func__, __LINE__,
+       dev_dbg(&dev->core, "%s:%d: %llxh\n", __func__, __LINE__,
                *bytes_waiting);
        return result;
 }
@@ -295,7 +297,7 @@ static int ps3_vuart_get_interrupt_status(struct ps3_system_bus_device *dev,
 
        *status = tmp & priv->interrupt_mask;
 
-       dev_dbg(&dev->core, "%s:%d: m %lxh, s %lxh, m&s %lxh\n",
+       dev_dbg(&dev->core, "%s:%d: m %llxh, s %llxh, m&s %lxh\n",
                __func__, __LINE__, priv->interrupt_mask, tmp, *status);
 
        return result;
@@ -363,7 +365,7 @@ int ps3_vuart_disable_interrupt_disconnect(struct ps3_system_bus_device *dev)
  */
 
 static int ps3_vuart_raw_write(struct ps3_system_bus_device *dev,
-       const void *buf, unsigned int bytes, unsigned long *bytes_written)
+       const void *buf, unsigned int bytes, u64 *bytes_written)
 {
        int result;
        struct ps3_vuart_port_priv *priv = to_port_priv(dev);
@@ -379,7 +381,7 @@ static int ps3_vuart_raw_write(struct ps3_system_bus_device *dev,
 
        priv->stats.bytes_written += *bytes_written;
 
-       dev_dbg(&dev->core, "%s:%d: wrote %lxh/%xh=>%lxh\n", __func__, __LINE__,
+       dev_dbg(&dev->core, "%s:%d: wrote %llxh/%xh=>%lxh\n", __func__, __LINE__,
                *bytes_written, bytes, priv->stats.bytes_written);
 
        return result;
@@ -393,7 +395,7 @@ static int ps3_vuart_raw_write(struct ps3_system_bus_device *dev,
  */
 
 static int ps3_vuart_raw_read(struct ps3_system_bus_device *dev, void *buf,
-       unsigned int bytes, unsigned long *bytes_read)
+       unsigned int bytes, u64 *bytes_read)
 {
        int result;
        struct ps3_vuart_port_priv *priv = to_port_priv(dev);
@@ -411,7 +413,7 @@ static int ps3_vuart_raw_read(struct ps3_system_bus_device *dev, void *buf,
 
        priv->stats.bytes_read += *bytes_read;
 
-       dev_dbg(&dev->core, "%s:%d: read %lxh/%xh=>%lxh\n", __func__, __LINE__,
+       dev_dbg(&dev->core, "%s:%d: read %llxh/%xh=>%lxh\n", __func__, __LINE__,
                *bytes_read, bytes, priv->stats.bytes_read);
 
        return result;
@@ -500,7 +502,7 @@ int ps3_vuart_write(struct ps3_system_bus_device *dev, const void *buf,
        spin_lock_irqsave(&priv->tx_list.lock, flags);
 
        if (list_empty(&priv->tx_list.head)) {
-               unsigned long bytes_written;
+               u64 bytes_written;
 
                result = ps3_vuart_raw_write(dev, buf, bytes, &bytes_written);
 
@@ -592,7 +594,7 @@ static int ps3_vuart_queue_rx_bytes(struct ps3_system_bus_device *dev,
        list_add_tail(&lb->link, &priv->rx_list.head);
        priv->rx_list.bytes_held += bytes;
 
-       dev_dbg(&dev->core, "%s:%d: buf_%lu: queued %lxh bytes\n",
+       dev_dbg(&dev->core, "%s:%d: buf_%lu: queued %llxh bytes\n",
                __func__, __LINE__, lb->dbg_number, bytes);
 
        *bytes_queued = bytes;
@@ -745,7 +747,7 @@ static int ps3_vuart_handle_interrupt_tx(struct ps3_system_bus_device *dev)
 
        list_for_each_entry_safe(lb, n, &priv->tx_list.head, link) {
 
-               unsigned long bytes_written;
+               u64 bytes_written;
 
                result = ps3_vuart_raw_write(dev, lb->head, lb->tail - lb->head,
                        &bytes_written);
@@ -762,7 +764,7 @@ static int ps3_vuart_handle_interrupt_tx(struct ps3_system_bus_device *dev)
                if (bytes_written < lb->tail - lb->head) {
                        lb->head += bytes_written;
                        dev_dbg(&dev->core,
-                               "%s:%d cleared buf_%lu, %lxh bytes\n",
+                               "%s:%d cleared buf_%lu, %llxh bytes\n",
                                __func__, __LINE__, lb->dbg_number,
                                bytes_written);
                        goto port_full;

diff --git a/drivers/ps3/ps3stor_lib.c b/drivers/ps3/ps3stor_lib.c
index 55955f16ad919ad7fb6d5aeadbb4334733fa1e71..18066d55539764abd94c9b157f4392c303236083 100644 (file)
--- a/drivers/ps3/ps3stor_lib.c
+++ b/drivers/ps3/ps3stor_lib.c
@@ -70,7 +70,7 @@ static int ps3stor_probe_access(struct ps3_storage_device *dev)
                         __func__, __LINE__, n);
        dev->region_idx = __ffs(dev->accessible_regions);
        dev_info(&dev->sbd.core,
-                "First accessible region has index %u start %lu size %lu\n",
+                "First accessible region has index %u start %llu size %llu\n",
                 dev->region_idx, dev->regions[dev->region_idx].start,
                 dev->regions[dev->region_idx].size);
 
@@ -220,7 +220,7 @@ u64 ps3stor_read_write_sectors(struct ps3_storage_device *dev, u64 lpar,
        const char *op = write ? "write" : "read";
        int res;
 
-       dev_dbg(&dev->sbd.core, "%s:%u: %s %lu sectors starting at %lu\n",
+       dev_dbg(&dev->sbd.core, "%s:%u: %s %llu sectors starting at %llu\n",
                __func__, __LINE__, op, sectors, start_sector);
 
        init_completion(&dev->done);
@@ -238,7 +238,7 @@ u64 ps3stor_read_write_sectors(struct ps3_storage_device *dev, u64 lpar,
 
        wait_for_completion(&dev->done);
        if (dev->lv1_status) {
-               dev_dbg(&dev->sbd.core, "%s:%u: %s failed 0x%lx\n", __func__,
+               dev_dbg(&dev->sbd.core, "%s:%u: %s failed 0x%llx\n", __func__,
                        __LINE__, op, dev->lv1_status);
                return dev->lv1_status;
        }
@@ -268,7 +268,7 @@ u64 ps3stor_send_command(struct ps3_storage_device *dev, u64 cmd, u64 arg1,
 {
        int res;
 
-       dev_dbg(&dev->sbd.core, "%s:%u: send device command 0x%lx\n", __func__,
+       dev_dbg(&dev->sbd.core, "%s:%u: send device command 0x%llx\n", __func__,
                __LINE__, cmd);
 
        init_completion(&dev->done);
@@ -277,19 +277,19 @@ u64 ps3stor_send_command(struct ps3_storage_device *dev, u64 cmd, u64 arg1,
                                              arg2, arg3, arg4, &dev->tag);
        if (res) {
                dev_err(&dev->sbd.core,
-                       "%s:%u: send_device_command 0x%lx failed %d\n",
+                       "%s:%u: send_device_command 0x%llx failed %d\n",
                        __func__, __LINE__, cmd, res);
                return -1;
        }
 
        wait_for_completion(&dev->done);
        if (dev->lv1_status) {
-               dev_dbg(&dev->sbd.core, "%s:%u: command 0x%lx failed 0x%lx\n",
+               dev_dbg(&dev->sbd.core, "%s:%u: command 0x%llx failed 0x%llx\n",
                        __func__, __LINE__, cmd, dev->lv1_status);
                return dev->lv1_status;
        }
 
-       dev_dbg(&dev->sbd.core, "%s:%u: command 0x%lx completed\n", __func__,
+       dev_dbg(&dev->sbd.core, "%s:%u: command 0x%llx completed\n", __func__,
                __LINE__, cmd);
 
        return 0;

diff --git a/drivers/scsi/ibmvscsi/ibmvfc.c b/drivers/scsi/ibmvscsi/ibmvfc.c
index ee0739b217b6ed653ba969a75403d3d55f16f8d4..91ef669d98f64583e94fb9d57c4e855679cc680b 100644 (file)
--- a/drivers/scsi/ibmvscsi/ibmvfc.c
+++ b/drivers/scsi/ibmvscsi/ibmvfc.c
@@ -933,7 +933,7 @@ static void ibmvfc_get_host_speed(struct Scsi_Host *shost)
                        fc_host_speed(shost) = FC_PORTSPEED_16GBIT;
                        break;
                default:
-                       ibmvfc_log(vhost, 3, "Unknown port speed: %ld Gbit\n",
+                       ibmvfc_log(vhost, 3, "Unknown port speed: %lld Gbit\n",
                                   vhost->login_buf->resp.link_speed / 100);
                        fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
                        break;
@@ -2149,8 +2149,8 @@ static void ibmvfc_handle_async(struct ibmvfc_async_crq *crq,
 {
        const char *desc = ibmvfc_get_ae_desc(crq->event);
 
-       ibmvfc_log(vhost, 3, "%s event received. scsi_id: %lx, wwpn: %lx,"
-                  " node_name: %lx\n", desc, crq->scsi_id, crq->wwpn, crq->node_name);
+       ibmvfc_log(vhost, 3, "%s event received. scsi_id: %llx, wwpn: %llx,"
+                  " node_name: %llx\n", desc, crq->scsi_id, crq->wwpn, crq->node_name);
 
        switch (crq->event) {
        case IBMVFC_AE_LINK_UP:
@@ -2184,7 +2184,7 @@ static void ibmvfc_handle_async(struct ibmvfc_async_crq *crq,
                ibmvfc_link_down(vhost, IBMVFC_HALTED);
                break;
        default:
-               dev_err(vhost->dev, "Unknown async event received: %ld\n", crq->event);
+               dev_err(vhost->dev, "Unknown async event received: %lld\n", crq->event);
                break;
        };
 }
@@ -2261,13 +2261,13 @@ static void ibmvfc_handle_crq(struct ibmvfc_crq *crq, struct ibmvfc_host *vhost)
         * actually sent
         */
        if (unlikely(!ibmvfc_valid_event(&vhost->pool, evt))) {
-               dev_err(vhost->dev, "Returned correlation_token 0x%08lx is invalid!\n",
+               dev_err(vhost->dev, "Returned correlation_token 0x%08llx is invalid!\n",
                        crq->ioba);
                return;
        }
 
        if (unlikely(atomic_read(&evt->free))) {
-               dev_err(vhost->dev, "Received duplicate correlation_token 0x%08lx!\n",
+               dev_err(vhost->dev, "Received duplicate correlation_token 0x%08llx!\n",
                        crq->ioba);
                return;
        }
@@ -3259,7 +3259,7 @@ static int ibmvfc_alloc_target(struct ibmvfc_host *vhost, u64 scsi_id)
 
        tgt = mempool_alloc(vhost->tgt_pool, GFP_KERNEL);
        if (!tgt) {
-               dev_err(vhost->dev, "Target allocation failure for scsi id %08lx\n",
+               dev_err(vhost->dev, "Target allocation failure for scsi id %08llx\n",
                        scsi_id);
                return -ENOMEM;
        }

diff --git a/drivers/scsi/ibmvscsi/ibmvfc.h b/drivers/scsi/ibmvscsi/ibmvfc.h
index babdf3db59df9f92d332a5fb32f9b8e43ab370e4..87dafd0f8d4416b48e27bf08b3673d391a670abe 100644 (file)
--- a/drivers/scsi/ibmvscsi/ibmvfc.h
+++ b/drivers/scsi/ibmvscsi/ibmvfc.h
@@ -691,13 +691,13 @@ struct ibmvfc_host {
 #define DBG_CMD(CMD) do { if (ibmvfc_debug) CMD; } while (0)
 
 #define tgt_dbg(t, fmt, ...)                   \
-       DBG_CMD(dev_info((t)->vhost->dev, "%lX: " fmt, (t)->scsi_id, ##__VA_ARGS__))
+       DBG_CMD(dev_info((t)->vhost->dev, "%llX: " fmt, (t)->scsi_id, ##__VA_ARGS__))
 
 #define tgt_info(t, fmt, ...)          \
-       dev_info((t)->vhost->dev, "%lX: " fmt, (t)->scsi_id, ##__VA_ARGS__)
+       dev_info((t)->vhost->dev, "%llX: " fmt, (t)->scsi_id, ##__VA_ARGS__)
 
 #define tgt_err(t, fmt, ...)           \
-       dev_err((t)->vhost->dev, "%lX: " fmt, (t)->scsi_id, ##__VA_ARGS__)
+       dev_err((t)->vhost->dev, "%llX: " fmt, (t)->scsi_id, ##__VA_ARGS__)
 
 #define ibmvfc_dbg(vhost, ...) \
        DBG_CMD(dev_info((vhost)->dev, ##__VA_ARGS__))

diff --git a/drivers/scsi/ps3rom.c b/drivers/scsi/ps3rom.c
index ce48e2d0193c64e379a5cfd1cfe5ab14f2a9a29a..ca0dd33497ec2f7f70640e65d8fa75c99abbffb5 100644 (file)
--- a/drivers/scsi/ps3rom.c
+++ b/drivers/scsi/ps3rom.c
@@ -290,11 +290,11 @@ static irqreturn_t ps3rom_interrupt(int irq, void *data)
 
        if (tag != dev->tag)
                dev_err(&dev->sbd.core,
-                       "%s:%u: tag mismatch, got %lx, expected %lx\n",
+                       "%s:%u: tag mismatch, got %llx, expected %llx\n",
                        __func__, __LINE__, tag, dev->tag);
 
        if (res) {
-               dev_err(&dev->sbd.core, "%s:%u: res=%d status=0x%lx\n",
+               dev_err(&dev->sbd.core, "%s:%u: res=%d status=0x%llx\n",
                        __func__, __LINE__, res, status);
                return IRQ_HANDLED;
        }
@@ -364,7 +364,7 @@ static int __devinit ps3rom_probe(struct ps3_system_bus_device *_dev)
 
        if (dev->blk_size != CD_FRAMESIZE) {
                dev_err(&dev->sbd.core,
-                       "%s:%u: cannot handle block size %lu\n", __func__,
+                       "%s:%u: cannot handle block size %llu\n", __func__,
                        __LINE__, dev->blk_size);
                return -EINVAL;
        }

diff --git a/drivers/serial/of_serial.c b/drivers/serial/of_serial.c
index a821e3a3d664e93f18fa6dcb8e7e561ce4fc6076..14f8fa9135be49c664f64d80c9633bf1d405f85c 100644 (file)
--- a/drivers/serial/of_serial.c
+++ b/drivers/serial/of_serial.c
@@ -163,6 +163,7 @@ static struct of_device_id __devinitdata of_platform_serial_table[] = {
        { .type = "serial", .compatible = "ns16450",  .data = (void *)PORT_16450, },
        { .type = "serial", .compatible = "ns16550",  .data = (void *)PORT_16550, },
        { .type = "serial", .compatible = "ns16750",  .data = (void *)PORT_16750, },
+       { .type = "serial", .compatible = "ns16850",  .data = (void *)PORT_16850, },
 #ifdef CONFIG_SERIAL_OF_PLATFORM_NWPSERIAL
        { .type = "serial", .compatible = "ibm,qpace-nwp-serial",
                                        .data = (void *)PORT_NWPSERIAL, },

diff --git a/drivers/video/ps3fb.c b/drivers/video/ps3fb.c
index 38ac805db97d4bcb5cdca4866f0fd3cfb430dce3..87f826e4c958c8c19c5c6b8d9471f21c5481f0df 100644 (file)
--- a/drivers/video/ps3fb.c
+++ b/drivers/video/ps3fb.c
@@ -1006,7 +1006,7 @@ static int ps3fb_xdr_settings(u64 xdr_lpar, struct device *dev)
                        __func__, status);
                return -ENXIO;
        }
-       dev_dbg(dev, "video:%p ioif:%lx lpar:%lx size:%lx\n",
+       dev_dbg(dev, "video:%p ioif:%lx lpar:%llx size:%lx\n",
                ps3fb_videomemory.address, GPU_IOIF, xdr_lpar,
                ps3fb_videomemory.size);
 
@@ -1133,7 +1133,7 @@ static int __devinit ps3fb_probe(struct ps3_system_bus_device *dev)
                        __func__, status);
                goto err;
        }
-       dev_dbg(&dev->core, "ddr:lpar:0x%lx\n", ddr_lpar);
+       dev_dbg(&dev->core, "ddr:lpar:0x%llx\n", ddr_lpar);
 
        status = lv1_gpu_context_allocate(ps3fb.memory_handle, 0,
                                          &ps3fb.context_handle,

diff --git a/sound/ppc/snd_ps3.c b/sound/ppc/snd_ps3.c
index 8f9e3859c37ca70f802fdb5c3f8f25ed75731b8d..ff321110ec029604bd8cd0e4862940fe1e1b88c4 100644 (file)
--- a/sound/ppc/snd_ps3.c
+++ b/sound/ppc/snd_ps3.c
@@ -477,7 +477,7 @@ static int snd_ps3_pcm_prepare(struct snd_pcm_substream *substream)
                card->dma_start_bus_addr[SND_PS3_CH_R] =
                        runtime->dma_addr + (runtime->dma_bytes / 2);
 
-               pr_debug("%s: vaddr=%p bus=%#lx\n", __func__,
+               pr_debug("%s: vaddr=%p bus=%#llx\n", __func__,
                         card->dma_start_vaddr[SND_PS3_CH_L],
                         card->dma_start_bus_addr[SND_PS3_CH_L]);
 
@@ -1030,7 +1030,7 @@ static int __init snd_ps3_driver_probe(struct ps3_system_bus_device *dev)
                pr_info("%s: nullbuffer alloc failed\n", __func__);
                goto clean_preallocate;
        }
-       pr_debug("%s: null vaddr=%p dma=%#lx\n", __func__,
+       pr_debug("%s: null vaddr=%p dma=%#llx\n", __func__,
                 the_card.null_buffer_start_vaddr,
                 the_card.null_buffer_start_dma_addr);
        /* set default sample rate/word width */