#include <asm/smp.h>
 #include <asm/smp_plat.h>
 
-static int __cpuinit mcpm_boot_secondary(unsigned int cpu, struct task_struct *idle)
+static int mcpm_boot_secondary(unsigned int cpu, struct task_struct *idle)
 {
        unsigned int mpidr, pcpu, pcluster, ret;
        extern void secondary_startup(void);
        return 0;
 }
 
-static void __cpuinit mcpm_secondary_init(unsigned int cpu)
+static void mcpm_secondary_init(unsigned int cpu)
 {
        mcpm_cpu_powered_up();
 }
 
        return cval;
 }
 
-static inline void __cpuinit arch_counter_set_user_access(void)
+static inline void arch_counter_set_user_access(void)
 {
        u32 cntkctl;
 
 
  *     r5 = proc_info pointer in physical address space
  *     r9 = cpuid (preserved)
  */
-       __CPUINIT
 __lookup_processor_type:
        adr     r3, __lookup_processor_type_data
        ldmia   r3, {r4 - r6}
 
 ENDPROC(stext)
 
 #ifdef CONFIG_SMP
-       __CPUINIT
 ENTRY(secondary_startup)
        /*
         * Common entry point for secondary CPUs.
 
        .long   __turn_mmu_on_end
 
 #if defined(CONFIG_SMP)
-       __CPUINIT
 ENTRY(secondary_startup)
        /*
         * Common entry point for secondary CPUs.
 
                cpumask_or(&debug_err_mask, &debug_err_mask, cpumask_of(cpu));
 }
 
-static int __cpuinit dbg_reset_notify(struct notifier_block *self,
+static int dbg_reset_notify(struct notifier_block *self,
                                      unsigned long action, void *cpu)
 {
        if ((action & ~CPU_TASKS_FROZEN) == CPU_ONLINE)
        return NOTIFY_OK;
 }
 
-static struct notifier_block __cpuinitdata dbg_reset_nb = {
+static struct notifier_block dbg_reset_nb = {
        .notifier_call = dbg_reset_notify,
 };
 
 
  * UNKNOWN at reset, the PMU must be explicitly reset to avoid reading
  * junk values out of them.
  */
-static int __cpuinit cpu_pmu_notify(struct notifier_block *b,
-                                   unsigned long action, void *hcpu)
+static int cpu_pmu_notify(struct notifier_block *b, unsigned long action,
+                         void *hcpu)
 {
        if ((action & ~CPU_TASKS_FROZEN) != CPU_STARTING)
                return NOTIFY_DONE;
        return NOTIFY_OK;
 }
 
-static struct notifier_block __cpuinitdata cpu_pmu_hotplug_notifier = {
+static struct notifier_block cpu_pmu_hotplug_notifier = {
        .notifier_call = cpu_pmu_notify,
 };
 
 
 
 extern void secondary_startup(void);
 
-static int __cpuinit psci_boot_secondary(unsigned int cpu,
-                                        struct task_struct *idle)
+static int psci_boot_secondary(unsigned int cpu, struct task_struct *idle)
 {
        if (psci_ops.cpu_on)
                return psci_ops.cpu_on(cpu_logical_map(cpu),
 
  * control for which core is the next to come out of the secondary
  * boot "holding pen"
  */
-volatile int __cpuinitdata pen_release = -1;
+volatile int pen_release = -1;
 
 enum ipi_msg_type {
        IPI_WAKEUP,
        return pgdir >> ARCH_PGD_SHIFT;
 }
 
-int __cpuinit __cpu_up(unsigned int cpu, struct task_struct *idle)
+int __cpu_up(unsigned int cpu, struct task_struct *idle)
 {
        int ret;
 
                smp_ops.smp_init_cpus();
 }
 
-int __cpuinit boot_secondary(unsigned int cpu, struct task_struct *idle)
+int boot_secondary(unsigned int cpu, struct task_struct *idle)
 {
        if (smp_ops.smp_boot_secondary)
                return smp_ops.smp_boot_secondary(cpu, idle);
 /*
  * __cpu_disable runs on the processor to be shutdown.
  */
-int __cpuinit __cpu_disable(void)
+int __cpu_disable(void)
 {
        unsigned int cpu = smp_processor_id();
        int ret;
  * called on the thread which is asking for a CPU to be shutdown -
  * waits until shutdown has completed, or it is timed out.
  */
-void __cpuinit __cpu_die(unsigned int cpu)
+void __cpu_die(unsigned int cpu)
 {
        if (!wait_for_completion_timeout(&cpu_died, msecs_to_jiffies(5000))) {
                pr_err("CPU%u: cpu didn't die\n", cpu);
  * Called by both boot and secondaries to move global data into
  * per-processor storage.
  */
-static void __cpuinit smp_store_cpu_info(unsigned int cpuid)
+static void smp_store_cpu_info(unsigned int cpuid)
 {
        struct cpuinfo_arm *cpu_info = &per_cpu(cpu_data, cpuid);
 
  * This is the secondary CPU boot entry.  We're using this CPUs
  * idle thread stack, but a set of temporary page tables.
  */
-asmlinkage void __cpuinit secondary_start_kernel(void)
+asmlinkage void secondary_start_kernel(void)
 {
        struct mm_struct *mm = &init_mm;
        unsigned int cpu;
 {
 }
 
-static void __cpuinit broadcast_timer_setup(struct clock_event_device *evt)
+static void broadcast_timer_setup(struct clock_event_device *evt)
 {
        evt->name       = "dummy_timer";
        evt->features   = CLOCK_EVT_FEAT_ONESHOT |
 }
 #endif
 
-static void __cpuinit percpu_timer_setup(void)
+static void percpu_timer_setup(void)
 {
        unsigned int cpu = smp_processor_id();
        struct clock_event_device *evt = &per_cpu(percpu_clockevent, cpu);
 
 
 #endif
 
-static void __cpuinit twd_calibrate_rate(void)
+static void twd_calibrate_rate(void)
 {
        unsigned long count;
        u64 waitjiffies;
 /*
  * Setup the local clock events for a CPU.
  */
-static int __cpuinit twd_timer_setup(struct clock_event_device *clk)
+static int twd_timer_setup(struct clock_event_device *clk)
 {
        struct clock_event_device **this_cpu_clk;
        int cpu = smp_processor_id();
        return 0;
 }
 
-static struct local_timer_ops twd_lt_ops __cpuinitdata = {
+static struct local_timer_ops twd_lt_ops = {
        .setup  = twd_timer_setup,
        .stop   = twd_timer_stop,
 };
 
        }
 }
 
-unsigned long __cpuinit calibrate_delay_is_known(void)
+unsigned long calibrate_delay_is_known(void)
 {
        delay_calibrated = true;
        return lpj_fine;
 
 #include <linux/linkage.h>
 #include <linux/init.h>
 
-       __CPUINIT
-
 /*
  * exynos4 specific entry point for secondary CPUs.  This provides
  * a "holding pen" into which all secondary cores are held until we're
 
 
 static DEFINE_SPINLOCK(boot_lock);
 
-static void __cpuinit exynos_secondary_init(unsigned int cpu)
+static void exynos_secondary_init(unsigned int cpu)
 {
        /*
         * let the primary processor know we're out of the
        spin_unlock(&boot_lock);
 }
 
-static int __cpuinit exynos_boot_secondary(unsigned int cpu, struct task_struct *idle)
+static int exynos_boot_secondary(unsigned int cpu, struct task_struct *idle)
 {
        unsigned long timeout;
        unsigned long phys_cpu = cpu_logical_map(cpu);
 
 
 extern void secondary_startup(void);
 
-static int __cpuinit highbank_boot_secondary(unsigned int cpu, struct task_struct *idle)
+static int highbank_boot_secondary(unsigned int cpu, struct task_struct *idle)
 {
        highbank_set_cpu_jump(cpu, secondary_startup);
        arch_send_wakeup_ipi_mask(cpumask_of(cpu));
 
        writel_relaxed(val, scu_base);
 }
 
-static int __cpuinit imx_boot_secondary(unsigned int cpu, struct task_struct *idle)
+static int imx_boot_secondary(unsigned int cpu, struct task_struct *idle)
 {
        imx_set_cpu_jump(cpu, v7_secondary_startup);
        imx_enable_cpu(cpu, true);
 
 
 #include "keystone.h"
 
-static int __cpuinit keystone_smp_boot_secondary(unsigned int cpu,
+static int keystone_smp_boot_secondary(unsigned int cpu,
                                                struct task_struct *idle)
 {
        unsigned long start = virt_to_phys(&secondary_startup);
 
 #include <linux/linkage.h>
 #include <linux/init.h>
 
-       __CPUINIT
-
 /*
  * MSM specific entry point for secondary CPUs.  This provides
  * a "holding pen" into which all secondary cores are held until we're
 
        return ((read_cpuid_id() >> 4) & 3) + 1;
 }
 
-static void __cpuinit msm_secondary_init(unsigned int cpu)
+static void msm_secondary_init(unsigned int cpu)
 {
        /*
         * let the primary processor know we're out of the
        spin_unlock(&boot_lock);
 }
 
-static __cpuinit void prepare_cold_cpu(unsigned int cpu)
+static void prepare_cold_cpu(unsigned int cpu)
 {
        int ret;
        ret = scm_set_boot_addr(virt_to_phys(msm_secondary_startup),
                                  "address\n");
 }
 
-static int __cpuinit msm_boot_secondary(unsigned int cpu, struct task_struct *idle)
+static int msm_boot_secondary(unsigned int cpu, struct task_struct *idle)
 {
        unsigned long timeout;
        static int cold_boot_done;
 
 };
 
 #ifdef CONFIG_LOCAL_TIMERS
-static int __cpuinit msm_local_timer_setup(struct clock_event_device *evt)
+static int msm_local_timer_setup(struct clock_event_device *evt)
 {
        /* Use existing clock_event for cpu 0 */
        if (!smp_processor_id())
        disable_percpu_irq(evt->irq);
 }
 
-static struct local_timer_ops msm_local_timer_ops __cpuinitdata = {
+static struct local_timer_ops msm_local_timer_ops = {
        .setup  = msm_local_timer_setup,
        .stop   = msm_local_timer_stop,
 };
 
 #include <asm/cacheflush.h>
 #include "armada-370-xp.h"
 
-unsigned long __cpuinitdata coherency_phys_base;
+unsigned long coherency_phys_base;
 static void __iomem *coherency_base;
 static void __iomem *coherency_cpu_base;
 
 
 #include <linux/linkage.h>
 #include <linux/init.h>
 
-       __CPUINIT
-
 /*
  * Armada XP specific entry point for secondary CPUs.
  * We add the CPU to the coherency fabric and then jump to secondary
 
        }
 }
 
-static void __cpuinit armada_xp_secondary_init(unsigned int cpu)
+static void armada_xp_secondary_init(unsigned int cpu)
 {
        armada_xp_mpic_smp_cpu_init();
 }
 
-static int __cpuinit armada_xp_boot_secondary(unsigned int cpu,
-                                             struct task_struct *idle)
+static int armada_xp_boot_secondary(unsigned int cpu, struct task_struct *idle)
 {
        pr_info("Booting CPU %d\n", cpu);
 
 
 
 #include "omap44xx.h"
 
-       __CPUINIT
-
 /* Physical address needed since MMU not enabled yet on secondary core */
 #define AUX_CORE_BOOT0_PA                      0x48281800
 
 
  * @cpu : CPU ID
  * @power_state: CPU low power state.
  */
-int __cpuinit omap4_hotplug_cpu(unsigned int cpu, unsigned int power_state)
+int omap4_hotplug_cpu(unsigned int cpu, unsigned int power_state)
 {
        struct omap4_cpu_pm_info *pm_info = &per_cpu(omap4_pm_info, cpu);
        unsigned int cpu_state = 0;
 
        return scu_base;
 }
 
-static void __cpuinit omap4_secondary_init(unsigned int cpu)
+static void omap4_secondary_init(unsigned int cpu)
 {
        /*
         * Configure ACTRL and enable NS SMP bit access on CPU1 on HS device.
        spin_unlock(&boot_lock);
 }
 
-static int __cpuinit omap4_boot_secondary(unsigned int cpu, struct task_struct *idle)
+static int omap4_boot_secondary(unsigned int cpu, struct task_struct *idle)
 {
        static struct clockdomain *cpu1_clkdm;
        static bool booted;
 
 #endif
 
 #ifdef CONFIG_HOTPLUG_CPU
-static int __cpuinit irq_cpu_hotplug_notify(struct notifier_block *self,
-                                        unsigned long action, void *hcpu)
+static int irq_cpu_hotplug_notify(struct notifier_block *self,
+                                 unsigned long action, void *hcpu)
 {
        unsigned int cpu = (unsigned int)hcpu;
 
 
 #include <linux/linkage.h>
 #include <linux/init.h>
 
-       __CPUINIT
-
 /*
  * SIRFSOC specific entry point for secondary CPUs.  This provides
  * a "holding pen" into which all secondary cores are held until we're
 
        scu_base = (void __iomem *)SIRFSOC_VA(base);
 }
 
-static void __cpuinit sirfsoc_secondary_init(unsigned int cpu)
+static void sirfsoc_secondary_init(unsigned int cpu)
 {
        /*
         * let the primary processor know we're out of the
        {},
 };
 
-static int __cpuinit sirfsoc_boot_secondary(unsigned int cpu, struct task_struct *idle)
+static int sirfsoc_boot_secondary(unsigned int cpu, struct task_struct *idle)
 {
        unsigned long timeout;
        struct device_node *np;
 
 #include <linux/init.h>
 #include <asm/memory.h>
 
-       __CPUINIT
 /*
  * Boot code for secondary CPUs.
  *
 
 #include <linux/init.h>
 #include <asm/memory.h>
 
-       __CPUINIT
-
 ENTRY(shmobile_invalidate_start)
        bl      v7_invalidate_l1
        b       secondary_startup
 
 
 #define EMEV2_SCU_BASE 0x1e000000
 
-static int __cpuinit emev2_boot_secondary(unsigned int cpu, struct task_struct *idle)
+static int emev2_boot_secondary(unsigned int cpu, struct task_struct *idle)
 {
        arch_send_wakeup_ipi_mask(cpumask_of(cpu_logical_map(cpu)));
        return 0;
 
        return ret ? ret : 1;
 }
 
-static int __cpuinit r8a7779_boot_secondary(unsigned int cpu, struct task_struct *idle)
+static int r8a7779_boot_secondary(unsigned int cpu, struct task_struct *idle)
 {
        struct r8a7779_pm_ch *ch = NULL;
        int ret = -EIO;
 
 }
 #endif
 
-static int __cpuinit sh73a0_boot_secondary(unsigned int cpu, struct task_struct *idle)
+static int sh73a0_boot_secondary(unsigned int cpu, struct task_struct *idle)
 {
        cpu = cpu_logical_map(cpu);
 
 
 #include <linux/linkage.h>
 #include <linux/init.h>
 
-       __CPUINIT
        .arch   armv7-a
 
 ENTRY(secondary_trampoline)
 
 
 #include "core.h"
 
-static int __cpuinit socfpga_boot_secondary(unsigned int cpu, struct task_struct *idle)
+static int socfpga_boot_secondary(unsigned int cpu, struct task_struct *idle)
 {
        int trampoline_size = &secondary_trampoline_end - &secondary_trampoline;
 
 
 void spear_restart(enum reboot_mode, const char *);
 
 void spear13xx_secondary_startup(void);
-void __cpuinit spear13xx_cpu_die(unsigned int cpu);
+void spear13xx_cpu_die(unsigned int cpu);
 
 extern struct smp_operations spear13xx_smp_ops;
 
 
 
 static void __iomem *scu_base = IOMEM(VA_SCU_BASE);
 
-static void __cpuinit spear13xx_secondary_init(unsigned int cpu)
+static void spear13xx_secondary_init(unsigned int cpu)
 {
        /*
         * let the primary processor know we're out of the
        spin_unlock(&boot_lock);
 }
 
-static int __cpuinit spear13xx_boot_secondary(unsigned int cpu, struct task_struct *idle)
+static int spear13xx_boot_secondary(unsigned int cpu, struct task_struct *idle)
 {
        unsigned long timeout;
 
 
 
 #include "smp.h"
 
-static void __cpuinit write_pen_release(int val)
+static void write_pen_release(int val)
 {
        pen_release = val;
        smp_wmb();
 
 static DEFINE_SPINLOCK(boot_lock);
 
-void __cpuinit sti_secondary_init(unsigned int cpu)
+void sti_secondary_init(unsigned int cpu)
 {
        trace_hardirqs_off();
 
        spin_unlock(&boot_lock);
 }
 
-int __cpuinit sti_boot_secondary(unsigned int cpu, struct task_struct *idle)
+int sti_boot_secondary(unsigned int cpu, struct task_struct *idle)
 {
        unsigned long timeout;
 
 
 
 static cpumask_t tegra_cpu_init_mask;
 
-static void __cpuinit tegra_secondary_init(unsigned int cpu)
+static void tegra_secondary_init(unsigned int cpu)
 {
        cpumask_set_cpu(cpu, &tegra_cpu_init_mask);
 }
        return ret;
 }
 
-static int __cpuinit tegra_boot_secondary(unsigned int cpu,
+static int tegra_boot_secondary(unsigned int cpu,
                                          struct task_struct *idle)
 {
        if (IS_ENABLED(CONFIG_ARCH_TEGRA_2x_SOC) && tegra_chip_id == TEGRA20)
 
        [TEGRA_SUSPEND_LP0] = "LP0",
 };
 
-static int __cpuinit tegra_suspend_enter(suspend_state_t state)
+static int tegra_suspend_enter(suspend_state_t state)
 {
        enum tegra_suspend_mode mode = tegra_pmc_get_suspend_mode();
 
 
 
 static DEFINE_SPINLOCK(boot_lock);
 
-static void __cpuinit ux500_secondary_init(unsigned int cpu)
+static void ux500_secondary_init(unsigned int cpu)
 {
        /*
         * let the primary processor know we're out of the
        spin_unlock(&boot_lock);
 }
 
-static int __cpuinit ux500_boot_secondary(unsigned int cpu, struct task_struct *idle)
+static int ux500_boot_secondary(unsigned int cpu, struct task_struct *idle)
 {
        unsigned long timeout;
 
 
 extern char zynq_secondary_trampoline;
 extern char zynq_secondary_trampoline_jump;
 extern char zynq_secondary_trampoline_end;
-extern int __cpuinit zynq_cpun_start(u32 address, int cpu);
+extern int zynq_cpun_start(u32 address, int cpu);
 extern struct smp_operations zynq_smp_ops __initdata;
 #endif
 
 
 #include <linux/linkage.h>
 #include <linux/init.h>
 
-       __CPUINIT
-
 ENTRY(zynq_secondary_trampoline)
        ldr     r0, [pc]
        bx      r0
 
 /*
  * Store number of cores in the system
  * Because of scu_get_core_count() must be in __init section and can't
- * be called from zynq_cpun_start() because it is in __cpuinit section.
+ * be called from zynq_cpun_start() because it is not in __init section.
  */
 static int ncores;
 
-int __cpuinit zynq_cpun_start(u32 address, int cpu)
+int zynq_cpun_start(u32 address, int cpu)
 {
        u32 trampoline_code_size = &zynq_secondary_trampoline_end -
                                                &zynq_secondary_trampoline;
 }
 EXPORT_SYMBOL(zynq_cpun_start);
 
-static int __cpuinit zynq_boot_secondary(unsigned int cpu,
+static int zynq_boot_secondary(unsigned int cpu,
                                                struct task_struct *idle)
 {
        return zynq_cpun_start(virt_to_phys(secondary_startup), cpu);
 
 #endif /* CONFIG_MMU */
        mov     pc, lr
 
-       __CPUINIT
-
        .type   __arm1020_setup, #function
 __arm1020_setup:
        mov     r0, #0
 
 #endif /* CONFIG_MMU */
        mov     pc, lr
 
-       __CPUINIT
-
        .type   __arm1020e_setup, #function
 __arm1020e_setup:
        mov     r0, #0
 
 #endif /* CONFIG_MMU */
        mov     pc, lr
 
-       __CPUINIT
-
        .type   __arm1022_setup, #function
 __arm1022_setup:
        mov     r0, #0
 
 #endif /* CONFIG_MMU */
        mov     pc, lr
 
-
-       __CPUINIT
-
        .type   __arm1026_setup, #function
 __arm1026_setup:
        mov     r0, #0
 
 ENDPROC(cpu_arm720_reset)
                .popsection
 
-       __CPUINIT
-
        .type   __arm710_setup, #function
 __arm710_setup:
        mov     r0, #0
 
 ENDPROC(cpu_arm740_reset)
        .popsection
 
-       __CPUINIT
-
        .type   __arm740_setup, #function
 __arm740_setup:
        mov     r0, #0
 
 ENDPROC(cpu_arm7tdmi_reset)
                .popsection
 
-               __CPUINIT
-
                .type   __arm7tdmi_setup, #function
 __arm7tdmi_setup:
                mov     pc, lr
 
 ENDPROC(cpu_arm920_do_resume)
 #endif
 
-       __CPUINIT
-
        .type   __arm920_setup, #function
 __arm920_setup:
        mov     r0, #0
 
 #endif /* CONFIG_MMU */
        mov     pc, lr
 
-       __CPUINIT
-
        .type   __arm922_setup, #function
 __arm922_setup:
        mov     r0, #0
 
 #endif /* CONFIG_MMU */
        mov     pc, lr
 
-       __CPUINIT
-
        .type   __arm925_setup, #function
 __arm925_setup:
        mov     r0, #0
 
 ENDPROC(cpu_arm926_do_resume)
 #endif
 
-       __CPUINIT
-
        .type   __arm926_setup, #function
 __arm926_setup:
        mov     r0, #0
 
        @ define struct cpu_cache_fns (see <asm/cacheflush.h> and proc-macros.S)
        define_cache_functions arm940
 
-       __CPUINIT
-
        .type   __arm940_setup, #function
 __arm940_setup:
        mov     r0, #0
 
        mcr     p15, 0, r0, c7, c10, 4          @ drain WB
        mov     pc, lr
 
-       __CPUINIT
-
        .type   __arm946_setup, #function
 __arm946_setup:
        mov     r0, #0
 
 ENDPROC(cpu_arm9tdmi_reset)
                .popsection
 
-               __CPUINIT
-
                .type   __arm9tdmi_setup, #function
 __arm9tdmi_setup:
                mov     pc, lr
 
 #endif
        mov     pc, lr
 
-       __CPUINIT
-
        .type   __fa526_setup, #function
 __fa526_setup:
        /* On return of this routine, r0 must carry correct flags for CFG register */
 
 #endif
        mov     pc, lr
 
-       __CPUINIT
-
        .type   __feroceon_setup, #function
 __feroceon_setup:
        mov     r0, #0
 
 ENDPROC(cpu_mohawk_do_resume)
 #endif
 
-       __CPUINIT
-
        .type   __mohawk_setup, #function
 __mohawk_setup:
        mov     r0, #0
 
 #endif
        mov     pc, lr
 
-       __CPUINIT
-
        .type   __sa110_setup, #function
 __sa110_setup:
        mov     r10, #0
 
 ENDPROC(cpu_sa1100_do_resume)
 #endif
 
-       __CPUINIT
-
        .type   __sa1100_setup, #function
 __sa1100_setup:
        mov     r0, #0
 
 
        .align
 
-       __CPUINIT
-
 /*
  *     __v6_setup
  *
 
        mcr     p15, 0, \ttbr1, c2, c0, 1       @ load TTB1
        .endm
 
-       __CPUINIT
-
        /*   AT
         *  TFR   EV X F   I D LR    S
         * .EEE ..EE PUI. .T.T 4RVI ZWRS BLDP WCAM
        .type   v7_crval, #object
 v7_crval:
        crval   clear=0x2120c302, mmuset=0x10c03c7d, ucset=0x00c01c7c
-
-       .previous
 
        mcrr    p15, 0, \ttbr0, \zero, c2                       @ load TTBR0
        .endm
 
-       __CPUINIT
-
        /*
         *   AT
         *  TFR   EV X F   IHD LR    S
        .type   v7_crval, #object
 v7_crval:
        crval   clear=0x0120c302, mmuset=0x30c23c7d, ucset=0x00c01c7c
-
-       .previous
 
 
 #endif
 
-       __CPUINIT
-
 /*
  *     __v7_setup
  *
 
 ENDPROC(cpu_xsc3_do_resume)
 #endif
 
-       __CPUINIT
-
        .type   __xsc3_setup, #function
 __xsc3_setup:
        mov     r0, #PSR_F_BIT|PSR_I_BIT|SVC_MODE
 
 ENDPROC(cpu_xscale_do_resume)
 #endif
 
-       __CPUINIT
-
        .type   __xscale_setup, #function
 __xscale_setup:
        mcr     p15, 0, ip, c7, c7, 0           @ invalidate I, D caches & BTB
 
  * observers, irrespective of whether they're taking part in coherency
  * or not.  This is necessary for the hotplug code to work reliably.
  */
-static void __cpuinit write_pen_release(int val)
+static void write_pen_release(int val)
 {
        pen_release = val;
        smp_wmb();
 
 static DEFINE_SPINLOCK(boot_lock);
 
-void __cpuinit versatile_secondary_init(unsigned int cpu)
+void versatile_secondary_init(unsigned int cpu)
 {
        /*
         * let the primary processor know we're out of the
        spin_unlock(&boot_lock);
 }
 
-int __cpuinit versatile_boot_secondary(unsigned int cpu, struct task_struct *idle)
+int versatile_boot_secondary(unsigned int cpu, struct task_struct *idle)
 {
        unsigned long timeout;