return IRQ_HANDLED;
 }
 
-static void smp_psurge_message_pass(int target, int msg, unsigned long data,
-                                          int wait)
+static void smp_psurge_message_pass(int target, int msg)
 {
        int i;
 
        local_irq_restore(flags);
 }
 
-void smp_core99_message_pass(int target, int msg, unsigned long data, int wait)
+void smp_core99_message_pass(int target, int msg)
 {
        cpumask_t mask = CPU_MASK_ALL;
        /* make sure we're sending something that translates to an IPI */
 
 EXPORT_SYMBOL(cpu_possible_map);
 
 /* SMP operations for this machine */
-static struct smp_ops_t *smp_ops;
+struct smp_ops_t *smp_ops;
 
 /* all cpu mappings are 1-1 -- Cort */
 volatile unsigned long cpu_callin_map[NR_CPUS];
 #define PPC_MSG_XMON_BREAK     3
 
 static inline void
-smp_message_pass(int target, int msg, unsigned long data, int wait)
+smp_message_pass(int target, int msg)
 {
-       if (smp_ops){
+       if (smp_ops) {
                atomic_inc(&ipi_sent);
-               smp_ops->message_pass(target,msg,data,wait);
+               smp_ops->message_pass(target, msg);
        }
 }
 
 void smp_send_tlb_invalidate(int cpu)
 {
        if ( PVR_VER(mfspr(SPRN_PVR)) == 8 )
-               smp_message_pass(MSG_ALL_BUT_SELF, PPC_MSG_INVALIDATE_TLB, 0, 0);
+               smp_message_pass(MSG_ALL_BUT_SELF, PPC_MSG_INVALIDATE_TLB);
 }
 
 void smp_send_reschedule(int cpu)
         */
        /* This is only used if `cpu' is running an idle task,
           so it will reschedule itself anyway... */
-       smp_message_pass(cpu, PPC_MSG_RESCHEDULE, 0, 0);
+       smp_message_pass(cpu, PPC_MSG_RESCHEDULE);
 }
 
 #ifdef CONFIG_XMON
 void smp_send_xmon_break(int cpu)
 {
-       smp_message_pass(cpu, PPC_MSG_XMON_BREAK, 0, 0);
+       smp_message_pass(cpu, PPC_MSG_XMON_BREAK);
 }
 #endif /* CONFIG_XMON */
 
        spin_lock(&call_lock);
        call_data = &data;
        /* Send a message to all other CPUs and wait for them to respond */
-       smp_message_pass(target, PPC_MSG_CALL_FUNCTION, 0, 0);
+       smp_message_pass(target, PPC_MSG_CALL_FUNCTION);
 
        /* Wait for response */
        timeout = 1000000;
         smp_store_cpu_info(smp_processor_id());
        cpu_callin_map[smp_processor_id()] = 1;
 
-       smp_ops = ppc_md.smp_ops;
        if (smp_ops == NULL) {
                printk("SMP not supported on this machine.\n");
                return;
        /* Backup CPU 0 state */
        __save_cpu_setup();
 
-       if (smp_ops->space_timers)
-               smp_ops->space_timers(num_cpus);
-
        for_each_cpu(cpu) {
                if (cpu == smp_processor_id())
                        continue;
 
 }
 
 static void
-smp_hdpu_message_pass(int target, int msg, unsigned long data, int wait)
+smp_hdpu_message_pass(int target, int msg)
 {
        if (msg > 0x3) {
                printk("SMP %d: smp_message_pass: unknown msg %d\n",
 #endif                         /* CONFIG_SERIAL_TEXT_DEBUG */
 
 #ifdef CONFIG_SMP
-       ppc_md.smp_ops = &hdpu_smp_ops;
+       smp_ops = &hdpu_smp_ops;
 #endif                         /* CONFIG_SMP */
 
 #if defined(CONFIG_SERIAL_MPSC) || defined(CONFIG_MV643XX_ETH)