a44e103c5a636670bdbd358f5143419c24d19d7a
[linux-2.6.git] / arch / tile / kernel / smp.c
1 /*
2  * Copyright 2010 Tilera Corporation. All Rights Reserved.
3  *
4  *   This program is free software; you can redistribute it and/or
5  *   modify it under the terms of the GNU General Public License
6  *   as published by the Free Software Foundation, version 2.
7  *
8  *   This program is distributed in the hope that it will be useful, but
9  *   WITHOUT ANY WARRANTY; without even the implied warranty of
10  *   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
11  *   NON INFRINGEMENT.  See the GNU General Public License for
12  *   more details.
13  *
14  * TILE SMP support routines.
15  */
16
17 #include <linux/smp.h>
18 #include <linux/interrupt.h>
19 #include <linux/io.h>
20 #include <linux/irq.h>
21 #include <linux/module.h>
22 #include <asm/cacheflush.h>
23
24 HV_Topology smp_topology __write_once;
25 EXPORT_SYMBOL(smp_topology);
26
27 #if CHIP_HAS_IPI()
28 static unsigned long __iomem *ipi_mappings[NR_CPUS];
29 #endif
30
31
32 /*
33  * Top-level send_IPI*() functions to send messages to other cpus.
34  */
35
36 /* Set by smp_send_stop() to avoid recursive panics. */
37 static int stopping_cpus;
38
39 static void __send_IPI_many(HV_Recipient *recip, int nrecip, int tag)
40 {
41         int sent = 0;
42         while (sent < nrecip) {
43                 int rc = hv_send_message(recip, nrecip,
44                                          (HV_VirtAddr)&tag, sizeof(tag));
45                 if (rc < 0) {
46                         if (!stopping_cpus)  /* avoid recursive panic */
47                                 panic("hv_send_message returned %d", rc);
48                         break;
49                 }
50                 WARN_ONCE(rc == 0, "hv_send_message() returned zero\n");
51                 sent += rc;
52         }
53 }
54
55 void send_IPI_single(int cpu, int tag)
56 {
57         HV_Recipient recip = {
58                 .y = cpu / smp_width,
59                 .x = cpu % smp_width,
60                 .state = HV_TO_BE_SENT
61         };
62         __send_IPI_many(&recip, 1, tag);
63 }
64
65 void send_IPI_many(const struct cpumask *mask, int tag)
66 {
67         HV_Recipient recip[NR_CPUS];
68         int cpu;
69         int nrecip = 0;
70         int my_cpu = smp_processor_id();
71         for_each_cpu(cpu, mask) {
72                 HV_Recipient *r;
73                 BUG_ON(cpu == my_cpu);
74                 r = &recip[nrecip++];
75                 r->y = cpu / smp_width;
76                 r->x = cpu % smp_width;
77                 r->state = HV_TO_BE_SENT;
78         }
79         __send_IPI_many(recip, nrecip, tag);
80 }
81
82 void send_IPI_allbutself(int tag)
83 {
84         struct cpumask mask;
85         cpumask_copy(&mask, cpu_online_mask);
86         cpumask_clear_cpu(smp_processor_id(), &mask);
87         send_IPI_many(&mask, tag);
88 }
89
90 /*
91  * Functions related to starting/stopping cpus.
92  */
93
94 /* Handler to start the current cpu. */
95 static void smp_start_cpu_interrupt(void)
96 {
97         get_irq_regs()->pc = start_cpu_function_addr;
98 }
99
100 /* Handler to stop the current cpu. */
101 static void smp_stop_cpu_interrupt(void)
102 {
103         set_cpu_online(smp_processor_id(), 0);
104         arch_local_irq_disable_all();
105         for (;;)
106                 asm("nap");
107 }
108
109 /* This function calls the 'stop' function on all other CPUs in the system. */
110 void smp_send_stop(void)
111 {
112         stopping_cpus = 1;
113         send_IPI_allbutself(MSG_TAG_STOP_CPU);
114 }
115
116
117 /*
118  * Dispatch code called from hv_message_intr() for HV_MSG_TILE hv messages.
119  */
120 void evaluate_message(int tag)
121 {
122         switch (tag) {
123         case MSG_TAG_START_CPU: /* Start up a cpu */
124                 smp_start_cpu_interrupt();
125                 break;
126
127         case MSG_TAG_STOP_CPU: /* Sent to shut down slave CPU's */
128                 smp_stop_cpu_interrupt();
129                 break;
130
131         case MSG_TAG_CALL_FUNCTION_MANY: /* Call function on cpumask */
132                 generic_smp_call_function_interrupt();
133                 break;
134
135         case MSG_TAG_CALL_FUNCTION_SINGLE: /* Call function on one other CPU */
136                 generic_smp_call_function_single_interrupt();
137                 break;
138
139         default:
140                 panic("Unknown IPI message tag %d", tag);
141                 break;
142         }
143 }
144
145
146 /*
147  * flush_icache_range() code uses smp_call_function().
148  */
149
150 struct ipi_flush {
151         unsigned long start;
152         unsigned long end;
153 };
154
155 static void ipi_flush_icache_range(void *info)
156 {
157         struct ipi_flush *flush = (struct ipi_flush *) info;
158         __flush_icache_range(flush->start, flush->end);
159 }
160
161 void flush_icache_range(unsigned long start, unsigned long end)
162 {
163         struct ipi_flush flush = { start, end };
164         preempt_disable();
165         on_each_cpu(ipi_flush_icache_range, &flush, 1);
166         preempt_enable();
167 }
168
169
170 /* Called when smp_send_reschedule() triggers IRQ_RESCHEDULE. */
171 static irqreturn_t handle_reschedule_ipi(int irq, void *token)
172 {
173         __get_cpu_var(irq_stat).irq_resched_count++;
174         scheduler_ipi();
175
176         return IRQ_HANDLED;
177 }
178
179 static struct irqaction resched_action = {
180         .handler = handle_reschedule_ipi,
181         .name = "resched",
182         .dev_id = handle_reschedule_ipi /* unique token */,
183 };
184
185 void __init ipi_init(void)
186 {
187 #if CHIP_HAS_IPI()
188         int cpu;
189         /* Map IPI trigger MMIO addresses. */
190         for_each_possible_cpu(cpu) {
191                 HV_Coord tile;
192                 HV_PTE pte;
193                 unsigned long offset;
194
195                 tile.x = cpu_x(cpu);
196                 tile.y = cpu_y(cpu);
197                 if (hv_get_ipi_pte(tile, KERNEL_PL, &pte) != 0)
198                         panic("Failed to initialize IPI for cpu %d\n", cpu);
199
200                 offset = hv_pte_get_pfn(pte) << PAGE_SHIFT;
201                 ipi_mappings[cpu] = ioremap_prot(offset, PAGE_SIZE, pte);
202         }
203 #endif
204
205         /* Bind handle_reschedule_ipi() to IRQ_RESCHEDULE. */
206         tile_irq_activate(IRQ_RESCHEDULE, TILE_IRQ_PERCPU);
207         BUG_ON(setup_irq(IRQ_RESCHEDULE, &resched_action));
208 }
209
210 #if CHIP_HAS_IPI()
211
212 void smp_send_reschedule(int cpu)
213 {
214         WARN_ON(cpu_is_offline(cpu));
215
216         /*
217          * We just want to do an MMIO store.  The traditional writeq()
218          * functions aren't really correct here, since they're always
219          * directed at the PCI shim.  For now, just do a raw store,
220          * casting away the __iomem attribute.
221          */
222         ((unsigned long __force *)ipi_mappings[cpu])[IRQ_RESCHEDULE] = 0;
223 }
224
225 #else
226
227 void smp_send_reschedule(int cpu)
228 {
229         HV_Coord coord;
230
231         WARN_ON(cpu_is_offline(cpu));
232
233         coord.y = cpu_y(cpu);
234         coord.x = cpu_x(cpu);
235         hv_trigger_ipi(coord, IRQ_RESCHEDULE);
236 }
237
238 #endif /* CHIP_HAS_IPI() */