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#include <asm/homecache.h>
 24
 25/*
 26 * We write to width and height with a single store in head_NN.S,
 27 * so make the variable aligned to "long".
 28 */
 29HV_Topology smp_topology __write_once __aligned(sizeof(long));
 30EXPORT_SYMBOL(smp_topology);
 31
 32#if CHIP_HAS_IPI()
 33static unsigned long __iomem *ipi_mappings[NR_CPUS];
 34#endif
 35
 36
 37/*
 38 * Top-level send_IPI*() functions to send messages to other cpus.
 39 */
 40
 41/* Set by smp_send_stop() to avoid recursive panics. */
 42static int stopping_cpus;
 43
 44static void __send_IPI_many(HV_Recipient *recip, int nrecip, int tag)
 45{
 46	int sent = 0;
 47	while (sent < nrecip) {
 48		int rc = hv_send_message(recip, nrecip,
 49					 (HV_VirtAddr)&tag, sizeof(tag));
 50		if (rc < 0) {
 51			if (!stopping_cpus)  /* avoid recursive panic */
 52				panic("hv_send_message returned %d", rc);
 53			break;
 54		}
 55		WARN_ONCE(rc == 0, "hv_send_message() returned zero\n");
 56		sent += rc;
 57	}
 58}
 59
 60void send_IPI_single(int cpu, int tag)
 61{
 62	HV_Recipient recip = {
 63		.y = cpu / smp_width,
 64		.x = cpu % smp_width,
 65		.state = HV_TO_BE_SENT
 66	};
 67	__send_IPI_many(&recip, 1, tag);
 68}
 69
 70void send_IPI_many(const struct cpumask *mask, int tag)
 71{
 72	HV_Recipient recip[NR_CPUS];
 73	int cpu;
 74	int nrecip = 0;
 75	int my_cpu = smp_processor_id();
 76	for_each_cpu(cpu, mask) {
 77		HV_Recipient *r;
 78		BUG_ON(cpu == my_cpu);
 79		r = &recip[nrecip++];
 80		r->y = cpu / smp_width;
 81		r->x = cpu % smp_width;
 82		r->state = HV_TO_BE_SENT;
 83	}
 84	__send_IPI_many(recip, nrecip, tag);
 85}
 86
 87void send_IPI_allbutself(int tag)
 88{
 89	struct cpumask mask;
 90	cpumask_copy(&mask, cpu_online_mask);
 91	cpumask_clear_cpu(smp_processor_id(), &mask);
 92	send_IPI_many(&mask, tag);
 93}
 94
 95/*
 96 * Functions related to starting/stopping cpus.
 97 */
 98
 99/* Handler to start the current cpu. */
100static void smp_start_cpu_interrupt(void)
101{
102	get_irq_regs()->pc = start_cpu_function_addr;
103}
104
105/* Handler to stop the current cpu. */
106static void smp_stop_cpu_interrupt(void)
107{
108	arch_local_irq_disable_all();
109	set_cpu_online(smp_processor_id(), 0);
110	for (;;)
111		asm("nap; nop");
112}
113
114/* This function calls the 'stop' function on all other CPUs in the system. */
115void smp_send_stop(void)
116{
117	stopping_cpus = 1;
118	send_IPI_allbutself(MSG_TAG_STOP_CPU);
119}
120
121/* On panic, just wait; we may get an smp_send_stop() later on. */
122void panic_smp_self_stop(void)
123{
124	while (1)
125		asm("nap; nop");
126}
127
128/*
129 * Dispatch code called from hv_message_intr() for HV_MSG_TILE hv messages.
130 */
131void evaluate_message(int tag)
132{
133	switch (tag) {
134	case MSG_TAG_START_CPU: /* Start up a cpu */
135		smp_start_cpu_interrupt();
136		break;
137
138	case MSG_TAG_STOP_CPU: /* Sent to shut down slave CPU's */
139		smp_stop_cpu_interrupt();
140		break;
141
142	case MSG_TAG_CALL_FUNCTION_MANY: /* Call function on cpumask */
143		generic_smp_call_function_interrupt();
144		break;
145
146	case MSG_TAG_CALL_FUNCTION_SINGLE: /* Call function on one other CPU */
147		generic_smp_call_function_single_interrupt();
148		break;
149
150	default:
151		panic("Unknown IPI message tag %d", tag);
152		break;
153	}
154}
155
156
157/*
158 * flush_icache_range() code uses smp_call_function().
159 */
160
161struct ipi_flush {
162	unsigned long start;
163	unsigned long end;
164};
165
166static void ipi_flush_icache_range(void *info)
167{
168	struct ipi_flush *flush = (struct ipi_flush *) info;
169	__flush_icache_range(flush->start, flush->end);
170}
171
172void flush_icache_range(unsigned long start, unsigned long end)
173{
174	struct ipi_flush flush = { start, end };
175
176	/* If invoked with irqs disabled, we can not issue IPIs. */
177	if (irqs_disabled())
178		flush_remote(0, HV_FLUSH_EVICT_L1I, NULL, 0, 0, 0,
179			NULL, NULL, 0);
180	else {
181		preempt_disable();
182		on_each_cpu(ipi_flush_icache_range, &flush, 1);
183		preempt_enable();
184	}
185}
186
187
188/* Called when smp_send_reschedule() triggers IRQ_RESCHEDULE. */
189static irqreturn_t handle_reschedule_ipi(int irq, void *token)
190{
191	__get_cpu_var(irq_stat).irq_resched_count++;
192	scheduler_ipi();
193
194	return IRQ_HANDLED;
195}
196
197static struct irqaction resched_action = {
198	.handler = handle_reschedule_ipi,
199	.name = "resched",
200	.dev_id = handle_reschedule_ipi /* unique token */,
201};
202
203void __init ipi_init(void)
204{
205#if CHIP_HAS_IPI()
206	int cpu;
207	/* Map IPI trigger MMIO addresses. */
208	for_each_possible_cpu(cpu) {
209		HV_Coord tile;
210		HV_PTE pte;
211		unsigned long offset;
212
213		tile.x = cpu_x(cpu);
214		tile.y = cpu_y(cpu);
215		if (hv_get_ipi_pte(tile, KERNEL_PL, &pte) != 0)
216			panic("Failed to initialize IPI for cpu %d\n", cpu);
217
218		offset = PFN_PHYS(pte_pfn(pte));
219		ipi_mappings[cpu] = ioremap_prot(offset, PAGE_SIZE, pte);
220	}
221#endif
222
223	/* Bind handle_reschedule_ipi() to IRQ_RESCHEDULE. */
224	tile_irq_activate(IRQ_RESCHEDULE, TILE_IRQ_PERCPU);
225	BUG_ON(setup_irq(IRQ_RESCHEDULE, &resched_action));
226}
227
228#if CHIP_HAS_IPI()
229
230void smp_send_reschedule(int cpu)
231{
232	WARN_ON(cpu_is_offline(cpu));
233
234	/*
235	 * We just want to do an MMIO store.  The traditional writeq()
236	 * functions aren't really correct here, since they're always
237	 * directed at the PCI shim.  For now, just do a raw store,
238	 * casting away the __iomem attribute.
239	 */
240	((unsigned long __force *)ipi_mappings[cpu])[IRQ_RESCHEDULE] = 0;
241}
242
243#else
244
245void smp_send_reschedule(int cpu)
246{
247	HV_Coord coord;
248
249	WARN_ON(cpu_is_offline(cpu));
250
251	coord.y = cpu_y(cpu);
252	coord.x = cpu_x(cpu);
253	hv_trigger_ipi(coord, IRQ_RESCHEDULE);
254}
255
256#endif /* CHIP_HAS_IPI() */