Merge branches 'clockevents/4.4-fixes' and 'clockevents/4.5-fixes' of http://git.linaro.org/people/daniel.lezcano/linux into timers/urgent

Pull in fixes from Daniel Lezcano:

 - Fix the vt8500 timer leading to a system lock up when dealing with too
   small delta (Roman Volkov)

 - Select the CLKSRC_MMIO when the fsl_ftm_timer is enabled with COMPILE_TEST
   (Daniel Lezcano)

 - Prevent to compile timers using the 'iomem' API when the architecture has
   not HAS_IOMEM set (Richard Weinberger)

10 files changed, 93 insertions, 106 deletions

diff --git a/arch/arc/kernel/ctx_sw.c b/arch/arc/kernel/ctx_sw.c
index c14a5bea0c76..5d446df2c413 100644
--- a/arch/arc/kernel/ctx_sw.c
+++ b/arch/arc/kernel/ctx_sw.c
@@ -58,8 +58,6 @@ __switch_to(struct task_struct *prev_task, struct task_struct *next_task)
                 "st      sp, [r24]       \n\t"
 #endif
 
-                "sync   \n\t"
-
                 /*
                  * setup _current_task with incoming tsk.
                  * optionally, set r25 to that as well
diff --git a/arch/arc/kernel/ctx_sw_asm.S b/arch/arc/kernel/ctx_sw_asm.S
index e248594097e7..e6890b1f8650 100644
--- a/arch/arc/kernel/ctx_sw_asm.S
+++ b/arch/arc/kernel/ctx_sw_asm.S
@@ -44,9 +44,6 @@ __switch_to:
         * don't need to do anything special to return it
         */
 
-        /* hardware memory barrier */
-        sync
-
         /*
          * switch to new task, contained in r1
          * Temp reg r3 is required to get the ptr to store val
diff --git a/arch/arc/kernel/intc-arcv2.c b/arch/arc/kernel/intc-arcv2.c
index 26c156827479..0394f9f61b46 100644
--- a/arch/arc/kernel/intc-arcv2.c
+++ b/arch/arc/kernel/intc-arcv2.c
@@ -106,10 +106,21 @@ static struct irq_chip arcv2_irq_chip = {
 static int arcv2_irq_map(struct irq_domain *d, unsigned int irq,
                          irq_hw_number_t hw)
 {
-        if (irq == TIMER0_IRQ || irq == IPI_IRQ)
+        /*
+         * core intc IRQs [16, 23]:
+         * Statically assigned always private-per-core (Timers, WDT, IPI, PCT)
+         */
+        if (hw < 24) {
+                /*
+                 * A subsequent request_percpu_irq() fails if percpu_devid is
+                 * not set. That in turns sets NOAUTOEN, meaning each core needs
+                 * to call enable_percpu_irq()
+                 */
+                irq_set_percpu_devid(irq);
                 irq_set_chip_and_handler(irq, &arcv2_irq_chip, handle_percpu_irq);
-        else
+        } else {
                 irq_set_chip_and_handler(irq, &arcv2_irq_chip, handle_level_irq);
+        }
 
         return 0;
 }
diff --git a/arch/arc/kernel/irq.c b/arch/arc/kernel/irq.c
index 2ee226546c6a..ba17f85285cf 100644
--- a/arch/arc/kernel/irq.c
+++ b/arch/arc/kernel/irq.c
@@ -29,11 +29,11 @@ void __init init_IRQ(void)
 
 #ifdef CONFIG_SMP
         /* a SMP H/w block could do IPI IRQ request here */
-        if (plat_smp_ops.init_irq_cpu)
-                plat_smp_ops.init_irq_cpu(smp_processor_id());
+        if (plat_smp_ops.init_per_cpu)
+                plat_smp_ops.init_per_cpu(smp_processor_id());
 
-        if (machine_desc->init_cpu_smp)
-                machine_desc->init_cpu_smp(smp_processor_id());
+        if (machine_desc->init_per_cpu)
+                machine_desc->init_per_cpu(smp_processor_id());
 #endif
 }
 
@@ -51,6 +51,18 @@ void arch_do_IRQ(unsigned int irq, struct pt_regs *regs)
         set_irq_regs(old_regs);
 }
 
+/*
+ * API called for requesting percpu interrupts - called by each CPU
+ *  - For boot CPU, actually request the IRQ with genirq core + enables
+ *  - For subsequent callers only enable called locally
+ *
+ * Relies on being called by boot cpu first (i.e. request called ahead) of
+ * any enable as expected by genirq. Hence Suitable only for TIMER, IPI
+ * which are guaranteed to be setup on boot core first.
+ * Late probed peripherals such as perf can't use this as there no guarantee
+ * of being called on boot CPU first.
+ */
+
 void arc_request_percpu_irq(int irq, int cpu,
                             irqreturn_t (*isr)(int irq, void *dev),
                             const char *irq_nm,
@@ -60,14 +72,17 @@ void arc_request_percpu_irq(int irq, int cpu,
         if (!cpu) {
                 int rc;
 
+#ifdef CONFIG_ISA_ARCOMPACT
                 /*
-                 * These 2 calls are essential to making percpu IRQ APIs work
-                 * Ideally these details could be hidden in irq chip map function
-                 * but the issue is IPIs IRQs being static (non-DT) and platform
-                 * specific, so we can't identify them there.
+                 * A subsequent request_percpu_irq() fails if percpu_devid is
+                 * not set. That in turns sets NOAUTOEN, meaning each core needs
+                 * to call enable_percpu_irq()
+                 *
+                 * For ARCv2, this is done in irq map function since we know
+                 * which irqs are strictly per cpu
                  */
                 irq_set_percpu_devid(irq);
-                irq_modify_status(irq, IRQ_NOAUTOEN, 0);  /* @irq, @clr, @set */
+#endif
 
                 rc = request_percpu_irq(irq, isr, irq_nm, percpu_dev);
                 if (rc)
diff --git a/arch/arc/kernel/mcip.c b/arch/arc/kernel/mcip.c
index 74a9b074ac3e..bd237acdf4f2 100644
--- a/arch/arc/kernel/mcip.c
+++ b/arch/arc/kernel/mcip.c
@@ -132,7 +132,7 @@ static void mcip_probe_n_setup(void)
 struct plat_smp_ops plat_smp_ops = {
         .info           = smp_cpuinfo_buf,
         .init_early_smp = mcip_probe_n_setup,
-        .init_irq_cpu   = mcip_setup_per_cpu,
+        .init_per_cpu   = mcip_setup_per_cpu,
         .ipi_send       = mcip_ipi_send,
         .ipi_clear      = mcip_ipi_clear,
 };
diff --git a/arch/arc/kernel/perf_event.c b/arch/arc/kernel/perf_event.c
index 0c08bb1ce15a..8b134cfe5e1f 100644
--- a/arch/arc/kernel/perf_event.c
+++ b/arch/arc/kernel/perf_event.c
@@ -428,12 +428,11 @@ static irqreturn_t arc_pmu_intr(int irq, void *dev)
 
 #endif /* CONFIG_ISA_ARCV2 */
 
-void arc_cpu_pmu_irq_init(void)
+static void arc_cpu_pmu_irq_init(void *data)
 {
-        struct arc_pmu_cpu *pmu_cpu = this_cpu_ptr(&arc_pmu_cpu);
+        int irq = *(int *)data;
 
-        arc_request_percpu_irq(arc_pmu->irq, smp_processor_id(), arc_pmu_intr,
-                               "ARC perf counters", pmu_cpu);
+        enable_percpu_irq(irq, IRQ_TYPE_NONE);
 
         /* Clear all pending interrupt flags */
         write_aux_reg(ARC_REG_PCT_INT_ACT, 0xffffffff);
@@ -515,7 +514,6 @@ static int arc_pmu_device_probe(struct platform_device *pdev)
 
         if (has_interrupts) {
                 int irq = platform_get_irq(pdev, 0);
-                unsigned long flags;
 
                 if (irq < 0) {
                         pr_err("Cannot get IRQ number for the platform\n");
@@ -524,24 +522,12 @@ static int arc_pmu_device_probe(struct platform_device *pdev)
 
                 arc_pmu->irq = irq;
 
-                /*
-                 * arc_cpu_pmu_irq_init() needs to be called on all cores for
-                 * their respective local PMU.
-                 * However we use opencoded on_each_cpu() to ensure it is called
-                 * on core0 first, so that arc_request_percpu_irq() sets up
-                 * AUTOEN etc. Otherwise enable_percpu_irq() fails to enable
-                 * perf IRQ on non master cores.
-                 * see arc_request_percpu_irq()
-                 */
-                preempt_disable();
-                local_irq_save(flags);
-                arc_cpu_pmu_irq_init();
-                local_irq_restore(flags);
-                smp_call_function((smp_call_func_t)arc_cpu_pmu_irq_init, 0, 1);
-                preempt_enable();
-
-                /* Clean all pending interrupt flags */
-                write_aux_reg(ARC_REG_PCT_INT_ACT, 0xffffffff);
+                /* intc map function ensures irq_set_percpu_devid() called */
+                request_percpu_irq(irq, arc_pmu_intr, "ARC perf counters",
+                                   this_cpu_ptr(&arc_pmu_cpu));
+
+                on_each_cpu(arc_cpu_pmu_irq_init, &irq, 1);
+
         } else
                 arc_pmu->pmu.capabilities |= PERF_PMU_CAP_NO_INTERRUPT;
 
diff --git a/arch/arc/kernel/process.c b/arch/arc/kernel/process.c
index 91d5a0f1f3f7..a3f750e76b68 100644
--- a/arch/arc/kernel/process.c
+++ b/arch/arc/kernel/process.c
@@ -44,11 +44,10 @@ SYSCALL_DEFINE0(arc_gettls)
 void arch_cpu_idle(void)
 {
         /* sleep, but enable all interrupts before committing */
-        if (is_isa_arcompact()) {
-                __asm__("sleep 0x3");
-        } else {
-                __asm__("sleep 0x10");
-        }
+        __asm__ __volatile__(
+                "sleep %0       \n"
+                :
+                :"I"(ISA_SLEEP_ARG)); /* can't be "r" has to be embedded const */
 }
 
 asmlinkage void ret_from_fork(void);
diff --git a/arch/arc/kernel/setup.c b/arch/arc/kernel/setup.c
index c33e77c0ad3e..e1b87444ea9a 100644
--- a/arch/arc/kernel/setup.c
+++ b/arch/arc/kernel/setup.c
@@ -429,7 +429,6 @@ void __init setup_arch(char **cmdline_p)
 #endif
 
         arc_unwind_init();
-        arc_unwind_setup();
 }
 
 static int __init customize_machine(void)
diff --git a/arch/arc/kernel/smp.c b/arch/arc/kernel/smp.c
index 580587805fa3..ef6e9e15b82a 100644
--- a/arch/arc/kernel/smp.c
+++ b/arch/arc/kernel/smp.c
@@ -132,11 +132,11 @@ void start_kernel_secondary(void)
         pr_info("## CPU%u LIVE ##: Executing Code...\n", cpu);
 
         /* Some SMP H/w setup - for each cpu */
-        if (plat_smp_ops.init_irq_cpu)
-                plat_smp_ops.init_irq_cpu(cpu);
+        if (plat_smp_ops.init_per_cpu)
+                plat_smp_ops.init_per_cpu(cpu);
 
-        if (machine_desc->init_cpu_smp)
-                machine_desc->init_cpu_smp(cpu);
+        if (machine_desc->init_per_cpu)
+                machine_desc->init_per_cpu(cpu);
 
         arc_local_timer_setup();
 
diff --git a/arch/arc/kernel/unwind.c b/arch/arc/kernel/unwind.c
index 93c6ea52b671..5eb707640e9c 100644
--- a/arch/arc/kernel/unwind.c
+++ b/arch/arc/kernel/unwind.c
@@ -170,6 +170,23 @@ static struct unwind_table *find_table(unsigned long pc)
 
 static unsigned long read_pointer(const u8 **pLoc,
                                   const void *end, signed ptrType);
+static void init_unwind_hdr(struct unwind_table *table,
+                            void *(*alloc) (unsigned long));
+
+/*
+ * wrappers for header alloc (vs. calling one vs. other at call site)
+ * to elide section mismatches warnings
+ */
+static void *__init unw_hdr_alloc_early(unsigned long sz)
+{
+        return __alloc_bootmem_nopanic(sz, sizeof(unsigned int),
+                                       MAX_DMA_ADDRESS);
+}
+
+static void *unw_hdr_alloc(unsigned long sz)
+{
+        return kmalloc(sz, GFP_KERNEL);
+}
 
 static void init_unwind_table(struct unwind_table *table, const char *name,
                               const void *core_start, unsigned long core_size,
@@ -209,6 +226,8 @@ void __init arc_unwind_init(void)
                           __start_unwind, __end_unwind - __start_unwind,
                           NULL, 0);
           /*__start_unwind_hdr, __end_unwind_hdr - __start_unwind_hdr);*/
+
+        init_unwind_hdr(&root_table, unw_hdr_alloc_early);
 }
 
 static const u32 bad_cie, not_fde;
@@ -241,8 +260,8 @@ static void swap_eh_frame_hdr_table_entries(void *p1, void *p2, int size)
         e2->fde = v;
 }
 
-static void __init setup_unwind_table(struct unwind_table *table,
-                                      void *(*alloc) (unsigned long))
+static void init_unwind_hdr(struct unwind_table *table,
+                            void *(*alloc) (unsigned long))
 {
         const u8 *ptr;
         unsigned long tableSize = table->size, hdrSize;
@@ -277,10 +296,10 @@ static void __init setup_unwind_table(struct unwind_table *table,
                 if (cie == &not_fde)
                         continue;
                 if (cie == NULL || cie == &bad_cie)
-                        return;
+                        goto ret_err;
                 ptrType = fde_pointer_type(cie);
                 if (ptrType < 0)
-                        return;
+                        goto ret_err;
 
                 ptr = (const u8 *)(fde + 2);
                 if (!read_pointer(&ptr, (const u8 *)(fde + 1) + *fde,
@@ -296,13 +315,15 @@ static void __init setup_unwind_table(struct unwind_table *table,
         }
 
         if (tableSize || !n)
-                return;
+                goto ret_err;
 
         hdrSize = 4 + sizeof(unsigned long) + sizeof(unsigned int)
             + 2 * n * sizeof(unsigned long);
+
         header = alloc(hdrSize);
         if (!header)
-                return;
+                goto ret_err;
+
         header->version = 1;
         header->eh_frame_ptr_enc = DW_EH_PE_abs | DW_EH_PE_native;
         header->fde_count_enc = DW_EH_PE_abs | DW_EH_PE_data4;
@@ -340,18 +361,10 @@ static void __init setup_unwind_table(struct unwind_table *table,
         table->hdrsz = hdrSize;
         smp_wmb();
         table->header = (const void *)header;
-}
-
-static void *__init balloc(unsigned long sz)
-{
-        return __alloc_bootmem_nopanic(sz,
-                                       sizeof(unsigned int),
-                                       __pa(MAX_DMA_ADDRESS));
-}
+        return;
 
-void __init arc_unwind_setup(void)
-{
-        setup_unwind_table(&root_table, balloc);
+ret_err:
+        panic("Attention !!! Dwarf FDE parsing errors\n");;
 }
 
 #ifdef CONFIG_MODULES
@@ -377,6 +390,8 @@ void *unwind_add_table(struct module *module, const void *table_start,
                           table_start, table_size,
                           NULL, 0);
 
+        init_unwind_hdr(table, unw_hdr_alloc);
+
 #ifdef UNWIND_DEBUG
         unw_debug("Table added for [%s] %lx %lx\n",
                 module->name, table->core.pc, table->core.range);
@@ -439,6 +454,7 @@ void unwind_remove_table(void *handle, int init_only)
         info.init_only = init_only;
 
         unlink_table(&info); /* XXX: SMP */
+        kfree(table->header);
         kfree(table);
 }
 
@@ -588,9 +604,6 @@ static signed fde_pointer_type(const u32 *cie)
         const u8 *ptr = (const u8 *)(cie + 2);
         unsigned version = *ptr;
 
-        if (version != 1)
-                return -1;      /* unsupported */
-
         if (*++ptr) {
                 const char *aug;
                 const u8 *end = (const u8 *)(cie + 1) + *cie;
@@ -986,42 +999,13 @@ int arc_unwind(struct unwind_frame_info *frame)
                                                             (const u8 *)(fde +
                                                                          1) +
                                                             *fde, ptrType);
-                                if (pc >= endLoc)
+                                if (pc >= endLoc) {
                                         fde = NULL;
-                        } else
-                                fde = NULL;
-                }
-                if (fde == NULL) {
-                        for (fde = table->address, tableSize = table->size;
-                             cie = NULL, tableSize > sizeof(*fde)
-                             && tableSize - sizeof(*fde) >= *fde;
-                             tableSize -= sizeof(*fde) + *fde,
-                             fde += 1 + *fde / sizeof(*fde)) {
-                                cie = cie_for_fde(fde, table);
-                                if (cie == &bad_cie) {
                                         cie = NULL;
-                                        break;
                                 }
-                                if (cie == NULL
-                                    || cie == &not_fde
-                                    || (ptrType = fde_pointer_type(cie)) < 0)
-                                        continue;
-                                ptr = (const u8 *)(fde + 2);
-                                startLoc = read_pointer(&ptr,
-                                                        (const u8 *)(fde + 1) +
-                                                        *fde, ptrType);
-                                if (!startLoc)
-                                        continue;
-                                if (!(ptrType & DW_EH_PE_indirect))
-                                        ptrType &=
-                                            DW_EH_PE_FORM | DW_EH_PE_signed;
-                                endLoc =
-                                    startLoc + read_pointer(&ptr,
-                                                            (const u8 *)(fde +
-                                                                         1) +
-                                                            *fde, ptrType);
-                                if (pc >= startLoc && pc < endLoc)
-                                        break;
+                        } else {
+                                fde = NULL;
+                                cie = NULL;
                         }
                 }
         }
@@ -1031,9 +1015,7 @@ int arc_unwind(struct unwind_frame_info *frame)
                 ptr = (const u8 *)(cie + 2);
                 end = (const u8 *)(cie + 1) + *cie;
                 frame->call_frame = 1;
-                if ((state.version = *ptr) != 1)
-                        cie = NULL;     /* unsupported version */
-                else if (*++ptr) {
+                if (*++ptr) {
                         /* check if augmentation size is first (thus present) */
                         if (*ptr == 'z') {
                                 while (++ptr < end && *ptr) {