[MIPS] Yosemite: Fix build damage by dc8f6029cd51af1b148846a32e68d69013a5cc0f.
[linux-2.6.git] / arch / mips / pmc-sierra / yosemite / smp.c
1 #include <linux/linkage.h>
2 #include <linux/sched.h>
3
4 #include <asm/pmon.h>
5 #include <asm/titan_dep.h>
6
7 extern unsigned int (*mips_hpt_read)(void);
8 extern void (*mips_hpt_init)(unsigned int);
9
10 #define LAUNCHSTACK_SIZE 256
11
12 static __initdata DEFINE_SPINLOCK(launch_lock);
13
14 static unsigned long secondary_sp __initdata;
15 static unsigned long secondary_gp __initdata;
16
17 static unsigned char launchstack[LAUNCHSTACK_SIZE] __initdata
18         __attribute__((aligned(2 * sizeof(long))));
19
20 static void __init prom_smp_bootstrap(void)
21 {
22         local_irq_disable();
23
24         while (spin_is_locked(&launch_lock));
25
26         __asm__ __volatile__(
27         "       move    $sp, %0         \n"
28         "       move    $gp, %1         \n"
29         "       j       smp_bootstrap   \n"
30         :
31         : "r" (secondary_sp), "r" (secondary_gp));
32 }
33
34 /*
35  * PMON is a fragile beast.  It'll blow up once the mappings it's littering
36  * right into the middle of KSEG3 are blown away so we have to grab the slave
37  * core early and keep it in a waiting loop.
38  */
39 void __init prom_grab_secondary(void)
40 {
41         spin_lock(&launch_lock);
42
43         pmon_cpustart(1, &prom_smp_bootstrap,
44                       launchstack + LAUNCHSTACK_SIZE, 0);
45 }
46
47 /*
48  * Detect available CPUs, populate phys_cpu_present_map before smp_init
49  *
50  * We don't want to start the secondary CPU yet nor do we have a nice probing
51  * feature in PMON so we just assume presence of the secondary core.
52  */
53 static char maxcpus_string[] __initdata =
54         KERN_WARNING "max_cpus set to 0; using 1 instead\n";
55
56 void __init prom_prepare_cpus(unsigned int max_cpus)
57 {
58         int enabled = 0, i;
59
60         if (max_cpus == 0) {
61                 printk(maxcpus_string);
62                 max_cpus = 1;
63         }
64
65         cpus_clear(phys_cpu_present_map);
66
67         for (i = 0; i < 2; i++) {
68                 if (i == max_cpus)
69                         break;
70
71                 /*
72                  * The boot CPU
73                  */
74                 cpu_set(i, phys_cpu_present_map);
75                 __cpu_number_map[i]     = i;
76                 __cpu_logical_map[i]    = i;
77                 enabled++;
78         }
79
80         /*
81          * Be paranoid.  Enable the IPI only if we're really about to go SMP.
82          */
83         if (enabled > 1)
84                 set_c0_status(STATUSF_IP5);
85 }
86
87 /*
88  * Firmware CPU startup hook
89  * Complicated by PMON's weird interface which tries to minimic the UNIX fork.
90  * It launches the next * available CPU and copies some information on the
91  * stack so the first thing we do is throw away that stuff and load useful
92  * values into the registers ...
93  */
94 void prom_boot_secondary(int cpu, struct task_struct *idle)
95 {
96         unsigned long gp = (unsigned long) task_thread_info(idle);
97         unsigned long sp = __KSTK_TOS(idle);
98
99         secondary_sp = sp;
100         secondary_gp = gp;
101
102         spin_unlock(&launch_lock);
103 }
104
105 /* Hook for after all CPUs are online */
106 void prom_cpus_done(void)
107 {
108 }
109
110 /*
111  *  After we've done initial boot, this function is called to allow the
112  *  board code to clean up state, if needed
113  */
114 void prom_init_secondary(void)
115 {
116         mips_hpt_init(mips_hpt_read());
117
118         set_c0_status(ST0_CO | ST0_IE | ST0_IM);
119 }
120
121 void prom_smp_finish(void)
122 {
123 }
124
125 asmlinkage void titan_mailbox_irq(struct pt_regs *regs)
126 {
127         int cpu = smp_processor_id();
128         unsigned long status;
129
130         if (cpu == 0) {
131                 status = OCD_READ(RM9000x2_OCD_INTP0STATUS3);
132                 OCD_WRITE(RM9000x2_OCD_INTP0CLEAR3, status);
133         }
134
135         if (cpu == 1) {
136                 status = OCD_READ(RM9000x2_OCD_INTP1STATUS3);
137                 OCD_WRITE(RM9000x2_OCD_INTP1CLEAR3, status);
138         }
139
140         if (status & 0x2)
141                 smp_call_function_interrupt();
142 }
143
144 /*
145  * Send inter-processor interrupt
146  */
147 void core_send_ipi(int cpu, unsigned int action)
148 {
149         /*
150          * Generate an INTMSG so that it can be sent over to the
151          * destination CPU. The INTMSG will put the STATUS bits
152          * based on the action desired. An alternative strategy
153          * is to write to the Interrupt Set register, read the
154          * Interrupt Status register and clear the Interrupt
155          * Clear register. The latter is preffered.
156          */
157         switch (action) {
158         case SMP_RESCHEDULE_YOURSELF:
159                 if (cpu == 1)
160                         OCD_WRITE(RM9000x2_OCD_INTP1SET3, 4);
161                 else
162                         OCD_WRITE(RM9000x2_OCD_INTP0SET3, 4);
163                 break;
164
165         case SMP_CALL_FUNCTION:
166                 if (cpu == 1)
167                         OCD_WRITE(RM9000x2_OCD_INTP1SET3, 2);
168                 else
169                         OCD_WRITE(RM9000x2_OCD_INTP0SET3, 2);
170                 break;
171         }
172 }