4 files changed, 72 insertions, 79 deletions

diff --git a/arch/arc/kernel/irq.c b/arch/arc/kernel/irq.c
index 7d653c0d0773..620ec2fe32a9 100644
--- a/arch/arc/kernel/irq.c
+++ b/arch/arc/kernel/irq.c
@@ -19,21 +19,16 @@
 
 /*
  * Early Hardware specific Interrupt setup
+ * -Platform independent, needed for each CPU (not foldable into init_IRQ)
  * -Called very early (start_kernel -> setup_arch -> setup_processor)
- * -Platform Independent (must for any ARC700)
- * -Needed for each CPU (hence not foldable into init_IRQ)
  *
  * what it does ?
- * -Disable all IRQs (on CPU side)
  * -Optionally, setup the High priority Interrupts as Level 2 IRQs
  */
 void arc_init_IRQ(void)
 {
         int level_mask = 0;
 
-        /* Disable all IRQs: enable them as devices request */
-        write_aux_reg(AUX_IENABLE, 0);
-
        /* setup any high priority Interrupts (Level2 in ARCompact jargon) */
         level_mask |= IS_ENABLED(CONFIG_ARC_IRQ3_LV2) << 3;
         level_mask |= IS_ENABLED(CONFIG_ARC_IRQ5_LV2) << 5;
@@ -60,20 +55,28 @@ void arc_init_IRQ(void)
  * below, per IRQ.
  */
 
-static void arc_mask_irq(struct irq_data *data)
+static void arc_irq_mask(struct irq_data *data)
 {
-        arch_mask_irq(data->irq);
+        unsigned int ienb;
+
+        ienb = read_aux_reg(AUX_IENABLE);
+        ienb &= ~(1 << data->irq);
+        write_aux_reg(AUX_IENABLE, ienb);
 }
 
-static void arc_unmask_irq(struct irq_data *data)
+static void arc_irq_unmask(struct irq_data *data)
 {
-        arch_unmask_irq(data->irq);
+        unsigned int ienb;
+
+        ienb = read_aux_reg(AUX_IENABLE);
+        ienb |= (1 << data->irq);
+        write_aux_reg(AUX_IENABLE, ienb);
 }
 
 static struct irq_chip onchip_intc = {
         .name           = "ARC In-core Intc",
-        .irq_mask       = arc_mask_irq,
-        .irq_unmask     = arc_unmask_irq,
+        .irq_mask       = arc_irq_mask,
+        .irq_unmask     = arc_irq_unmask,
 };
 
 static int arc_intc_domain_map(struct irq_domain *d, unsigned int irq,
@@ -150,6 +153,32 @@ void arch_do_IRQ(unsigned int irq, struct pt_regs *regs)
         set_irq_regs(old_regs);
 }
 
+void arc_request_percpu_irq(int irq, int cpu,
+                            irqreturn_t (*isr)(int irq, void *dev),
+                            const char *irq_nm,
+                            void *percpu_dev)
+{
+        /* Boot cpu calls request, all call enable */
+        if (!cpu) {
+                int rc;
+
+                /*
+                 * 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.
+                 */
+                irq_set_percpu_devid(irq);
+                irq_modify_status(irq, IRQ_NOAUTOEN, 0);  /* @irq, @clr, @set */
+
+                rc = request_percpu_irq(irq, isr, irq_nm, percpu_dev);
+                if (rc)
+                        panic("Percpu IRQ request failed for %d\n", irq);
+        }
+
+        enable_percpu_irq(irq, 0);
+}
+
 /*
  * arch_local_irq_enable - Enable interrupts.
  *
diff --git a/arch/arc/kernel/signal.c b/arch/arc/kernel/signal.c
index 7e95e1a86510..cb3142a2d40b 100644
--- a/arch/arc/kernel/signal.c
+++ b/arch/arc/kernel/signal.c
@@ -141,17 +141,13 @@ badframe:
 /*
  * Determine which stack to use..
  */
-static inline void __user *get_sigframe(struct k_sigaction *ka,
+static inline void __user *get_sigframe(struct ksignal *ksig,
                                         struct pt_regs *regs,
                                         unsigned long framesize)
 {
-        unsigned long sp = regs->sp;
+        unsigned long sp = sigsp(regs->sp, ksig);
         void __user *frame;
 
-        /* This is the X/Open sanctioned signal stack switching */
-        if ((ka->sa.sa_flags & SA_ONSTACK) && !sas_ss_flags(sp))
-                sp = current->sas_ss_sp + current->sas_ss_size;
-
         /* No matter what happens, 'sp' must be word
          * aligned otherwise nasty things could happen
          */
@@ -179,14 +175,13 @@ static inline int map_sig(int sig)
 }
 
 static int
-setup_rt_frame(int signo, struct k_sigaction *ka, siginfo_t *info,
-               sigset_t *set, struct pt_regs *regs)
+setup_rt_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs)
 {
         struct rt_sigframe __user *sf;
         unsigned int magic = 0;
         int err = 0;
 
-        sf = get_sigframe(ka, regs, sizeof(struct rt_sigframe));
+        sf = get_sigframe(ksig, regs, sizeof(struct rt_sigframe));
         if (!sf)
                 return 1;
 
@@ -205,8 +200,8 @@ setup_rt_frame(int signo, struct k_sigaction *ka, siginfo_t *info,
          *  #2: struct siginfo
          *  #3: struct ucontext (completely populated)
          */
-        if (unlikely(ka->sa.sa_flags & SA_SIGINFO)) {
-                err |= copy_siginfo_to_user(&sf->info, info);
+        if (unlikely(ksig->ka.sa.sa_flags & SA_SIGINFO)) {
+                err |= copy_siginfo_to_user(&sf->info, &ksig->info);
                 err |= __put_user(0, &sf->uc.uc_flags);
                 err |= __put_user(NULL, &sf->uc.uc_link);
                 err |= __save_altstack(&sf->uc.uc_stack, regs->sp);
@@ -227,16 +222,16 @@ setup_rt_frame(int signo, struct k_sigaction *ka, siginfo_t *info,
                 return err;
 
         /* #1 arg to the user Signal handler */
-        regs->r0 = map_sig(signo);
+        regs->r0 = map_sig(ksig->sig);
 
         /* setup PC of user space signal handler */
-        regs->ret = (unsigned long)ka->sa.sa_handler;
+        regs->ret = (unsigned long)ksig->ka.sa.sa_handler;
 
         /*
          * handler returns using sigreturn stub provided already by userpsace
          */
-        BUG_ON(!(ka->sa.sa_flags & SA_RESTORER));
-        regs->blink = (unsigned long)ka->sa.sa_restorer;
+        BUG_ON(!(ksig->ka.sa.sa_flags & SA_RESTORER));
+        regs->blink = (unsigned long)ksig->ka.sa.sa_restorer;
 
         /* User Stack for signal handler will be above the frame just carved */
         regs->sp = (unsigned long)sf;
@@ -298,38 +293,30 @@ static void arc_restart_syscall(struct k_sigaction *ka, struct pt_regs *regs)
  * OK, we're invoking a handler
  */
 static void
-handle_signal(unsigned long sig, struct k_sigaction *ka, siginfo_t *info,
-              struct pt_regs *regs)
+handle_signal(struct ksignal *ksig, struct pt_regs *regs)
 {
         sigset_t *oldset = sigmask_to_save();
         int ret;
 
         /* Set up the stack frame */
-        ret = setup_rt_frame(sig, ka, info, oldset, regs);
+        ret = setup_rt_frame(ksig, oldset, regs);
 
-        if (ret)
-                force_sigsegv(sig, current);
-        else
-                signal_delivered(sig, info, ka, regs, 0);
+        signal_setup_done(ret, ksig, 0);
 }
 
 void do_signal(struct pt_regs *regs)
 {
-        struct k_sigaction ka;
-        siginfo_t info;
-        int signr;
+        struct ksignal ksig;
         int restart_scall;
 
-        signr = get_signal_to_deliver(&info, &ka, regs, NULL);
-
         restart_scall = in_syscall(regs) && syscall_restartable(regs);
 
-        if (signr > 0) {
+        if (get_signal(&ksig)) {
                 if (restart_scall) {
-                        arc_restart_syscall(&ka, regs);
+                        arc_restart_syscall(&ksig.ka, regs);
                         syscall_wont_restart(regs);     /* No more restarts */
                 }
-                handle_signal(signr, &ka, &info, regs);
+                handle_signal(&ksig, regs);
                 return;
         }
 
diff --git a/arch/arc/kernel/smp.c b/arch/arc/kernel/smp.c
index c802bb500602..dcd317c47d09 100644
--- a/arch/arc/kernel/smp.c
+++ b/arch/arc/kernel/smp.c
@@ -12,23 +12,15 @@
  *    -- Initial Write (Borrowed heavily from ARM)
  */
 
-#include <linux/module.h>
-#include <linux/init.h>
 #include <linux/spinlock.h>
 #include <linux/sched.h>
 #include <linux/interrupt.h>
 #include <linux/profile.h>
-#include <linux/errno.h>
-#include <linux/err.h>
 #include <linux/mm.h>
 #include <linux/cpu.h>
-#include <linux/smp.h>
 #include <linux/irq.h>
-#include <linux/delay.h>
 #include <linux/atomic.h>
-#include <linux/percpu.h>
 #include <linux/cpumask.h>
-#include <linux/spinlock_types.h>
 #include <linux/reboot.h>
 #include <asm/processor.h>
 #include <asm/setup.h>
@@ -136,7 +128,7 @@ void start_kernel_secondary(void)
         pr_info("## CPU%u LIVE ##: Executing Code...\n", cpu);
 
         if (machine_desc->init_smp)
-                machine_desc->init_smp(smp_processor_id());
+                machine_desc->init_smp(cpu);
 
         arc_local_timer_setup();
 
@@ -338,18 +330,11 @@ irqreturn_t do_IPI(int irq, void *dev_id)
  */
 static DEFINE_PER_CPU(int, ipi_dev);
 
-static struct irqaction arc_ipi_irq = {
-        .name    = "IPI Interrupt",
-        .flags   = IRQF_PERCPU,
-        .handler = do_IPI,
-};
-
 int smp_ipi_irq_setup(int cpu, int irq)
 {
-        if (!cpu)
-                return setup_irq(irq, &arc_ipi_irq);
-        else
-                arch_unmask_irq(irq);
+        int *dev = per_cpu_ptr(&ipi_dev, cpu);
+
+        arc_request_percpu_irq(irq, cpu, do_IPI, "IPI Interrupt", dev);
 
         return 0;
 }
diff --git a/arch/arc/kernel/time.c b/arch/arc/kernel/time.c
index 36c2aa99436f..dbe74f418019 100644
--- a/arch/arc/kernel/time.c
+++ b/arch/arc/kernel/time.c
@@ -144,12 +144,12 @@ static struct clocksource arc_counter = {
 /********** Clock Event Device *********/
 
 /*
- * Arm the timer to interrupt after @limit cycles
+ * Arm the timer to interrupt after @cycles
  * The distinction for oneshot/periodic is done in arc_event_timer_ack() below
  */
-static void arc_timer_event_setup(unsigned int limit)
+static void arc_timer_event_setup(unsigned int cycles)
 {
-        write_aux_reg(ARC_REG_TIMER0_LIMIT, limit);
+        write_aux_reg(ARC_REG_TIMER0_LIMIT, cycles);
         write_aux_reg(ARC_REG_TIMER0_CNT, 0);   /* start from 0 */
 
         write_aux_reg(ARC_REG_TIMER0_CTRL, TIMER_CTRL_IE | TIMER_CTRL_NH);
@@ -168,6 +168,10 @@ static void arc_clkevent_set_mode(enum clock_event_mode mode,
 {
         switch (mode) {
         case CLOCK_EVT_MODE_PERIODIC:
+                /*
+                 * At X Hz, 1 sec = 1000ms -> X cycles;
+                 *                    10ms -> X / 100 cycles
+                 */
                 arc_timer_event_setup(arc_get_core_freq() / HZ);
                 break;
         case CLOCK_EVT_MODE_ONESHOT:
@@ -210,12 +214,6 @@ static irqreturn_t timer_irq_handler(int irq, void *dev_id)
         return IRQ_HANDLED;
 }
 
-static struct irqaction arc_timer_irq = {
-        .name    = "Timer0 (clock-evt-dev)",
-        .flags   = IRQF_TIMER | IRQF_PERCPU,
-        .handler = timer_irq_handler,
-};
-
 /*
  * Setup the local event timer for @cpu
  */
@@ -228,15 +226,9 @@ void arc_local_timer_setup()
         clockevents_config_and_register(evt, arc_get_core_freq(),
                                         0, ARC_TIMER_MAX);
 
-        /*
-         * setup the per-cpu timer IRQ handler - for all cpus
-         * For non boot CPU explicitly unmask at intc
-         * setup_irq() -> .. -> irq_startup() already does this on boot-cpu
-         */
-        if (!cpu)
-                setup_irq(TIMER0_IRQ, &arc_timer_irq);
-        else
-                arch_unmask_irq(TIMER0_IRQ);
+        /* setup the per-cpu timer IRQ handler - for all cpus */
+        arc_request_percpu_irq(TIMER0_IRQ, cpu, timer_irq_handler,
+                               "Timer0 (per-cpu-tick)", evt);
 }
 
 /*