[MIPS] time: SMP/NUMA-proofing of IP27 HUB RT timer code. (06d428d7) · Commits · jan.koester / Linux

arch/mips/sgi-ip27/ip27-init.c

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -110,7 +110,7 @@ static void __init per_hub_init(cnodeid_t cnode)
	}		}
	}		}

	void __init per_cpu_init(void)		void __cpuinit per_cpu_init(void)
	{		{
	int cpu = smp_processor_id();		int cpu = smp_processor_id();
	int slice = LOCAL_HUB_L(PI_CPU_NUM);		int slice = LOCAL_HUB_L(PI_CPU_NUM);

arch/mips/sgi-ip27/ip27-timer.c

+71 −63

Original line number	Original line	Diff line number	Diff line
	@@ -111,8 +111,24 @@ unsigned long read_persistent_clock(void)
	return mktime(year, month, date, hour, min, sec);		return mktime(year, month, date, hour, min, sec);
	}		}

	static int rt_set_next_event(unsigned long delta,		static void enable_rt_irq(unsigned int irq)
	struct clock_event_device *evt)		{
			}

			static void disable_rt_irq(unsigned int irq)
			{
			}

			static struct irq_chip rt_irq_type = {
			.name = "SN HUB RT timer",
			.ack = disable_rt_irq,
			.mask = disable_rt_irq,
			.mask_ack = disable_rt_irq,
			.unmask = enable_rt_irq,
			.eoi = enable_rt_irq,
			};

			static int rt_next_event(unsigned long delta, struct clock_event_device *evt)
	{		{
	unsigned int cpu = smp_processor_id();		unsigned int cpu = smp_processor_id();
	int slice = cputoslice(cpu) == 0;		int slice = cputoslice(cpu) == 0;
	@@ -129,50 +145,24 @@ static void rt_set_mode(enum clock_event_mode mode,
	struct clock_event_device *evt)		struct clock_event_device *evt)
	{		{
	switch (mode) {		switch (mode) {
	case CLOCK_EVT_MODE_PERIODIC:		case CLOCK_EVT_MODE_ONESHOT:
	/* The only mode supported */		/* The only mode supported */
	break;		break;

			case CLOCK_EVT_MODE_PERIODIC:
	case CLOCK_EVT_MODE_UNUSED:		case CLOCK_EVT_MODE_UNUSED:
	case CLOCK_EVT_MODE_SHUTDOWN:		case CLOCK_EVT_MODE_SHUTDOWN:
	case CLOCK_EVT_MODE_ONESHOT:
	case CLOCK_EVT_MODE_RESUME:		case CLOCK_EVT_MODE_RESUME:
	/* Nothing to do */		/* Nothing to do */
	break;		break;
	}		}
	}		}

	struct clock_event_device rt_clock_event_device = {
	.name = "HUB-RT",
	.features = CLOCK_EVT_FEAT_ONESHOT,

	.rating = 300,
	.set_next_event = rt_set_next_event,
	.set_mode = rt_set_mode,
	};

	static void enable_rt_irq(unsigned int irq)
	{
	}

	static void disable_rt_irq(unsigned int irq)
	{
	}

	static struct irq_chip rt_irq_type = {
	.name = "SN HUB RT timer",
	.ack = disable_rt_irq,
	.mask = disable_rt_irq,
	.mask_ack = disable_rt_irq,
	.unmask = enable_rt_irq,
	.eoi = enable_rt_irq,
	};

	unsigned int rt_timer_irq;		unsigned int rt_timer_irq;

	static irqreturn_t ip27_rt_timer_interrupt(int irq, void *dev_id)		static irqreturn_t hub_rt_counter_handler(int irq, void *dev_id)
	{		{
	struct clock_event_device *cd = &rt_clock_event_device;		struct clock_event_device *cd = dev_id;
	unsigned int cpu = smp_processor_id();		unsigned int cpu = smp_processor_id();
	int slice = cputoslice(cpu) == 0;		int slice = cputoslice(cpu) == 0;

	@@ -182,11 +172,10 @@ static irqreturn_t ip27_rt_timer_interrupt(int irq, void *dev_id)
	return IRQ_HANDLED;		return IRQ_HANDLED;
	}		}

	static struct irqaction rt_irqaction = {		struct irqaction hub_rt_irqaction = {
	.handler = (irq_handler_t) ip27_rt_timer_interrupt,		.handler = hub_rt_counter_handler,
	.flags = IRQF_DISABLED,		.flags = IRQF_DISABLED \| IRQF_PERCPU,
	.mask = CPU_MASK_NONE,		.name = "hub-rt",
	.name = "timer"
	};		};

	/*		/*
	@@ -200,32 +189,48 @@ static struct irqaction rt_irqaction = {
	#define NSEC_PER_CYCLE 800		#define NSEC_PER_CYCLE 800
	#define CYCLES_PER_SEC (NSEC_PER_SEC / NSEC_PER_CYCLE)		#define CYCLES_PER_SEC (NSEC_PER_SEC / NSEC_PER_CYCLE)

	static void __init ip27_rt_clock_event_init(void)		static DEFINE_PER_CPU(struct clock_event_device, hub_rt_clockevent);
			static DEFINE_PER_CPU(char [11], hub_rt_name);

			static void __cpuinit hub_rt_clock_event_init(void)
	{		{
	struct clock_event_device *cd = &rt_clock_event_device;
	unsigned int cpu = smp_processor_id();		unsigned int cpu = smp_processor_id();
	int irq = allocate_irqno();		struct clock_event_device *cd = &per_cpu(hub_rt_clockevent, cpu);
			unsigned char *name = per_cpu(hub_rt_name, cpu);
	if (irq < 0)		int irq = rt_timer_irq;
	panic("Can't allocate interrupt number for timer interrupt");
			sprintf(name, "hub-rt %d", cpu);
	rt_timer_irq = irq;		cd->name = "HUB-RT",
			cd->features = CLOCK_EVT_FEAT_ONESHOT,
			clockevent_set_clock(cd, CYCLES_PER_SEC);
			cd->max_delta_ns = clockevent_delta2ns(0xfffffffffffff, cd);
			cd->min_delta_ns = clockevent_delta2ns(0x300, cd);
			cd->rating = 200,
	cd->irq = irq,		cd->irq = irq,
	cd->cpumask = cpumask_of_cpu(cpu),		cd->cpumask = cpumask_of_cpu(cpu),
			cd->rating = 300,
	/*		cd->set_next_event = rt_next_event,
	* Calculate the min / max delta		cd->set_mode = rt_set_mode,
	*/
	cd->mult =
	div_sc((unsigned long) CYCLES_PER_SEC, NSEC_PER_SEC, 32);
	cd->shift = 32;
	cd->max_delta_ns = clockevent_delta2ns(0x7fffffff, cd);
	cd->min_delta_ns = clockevent_delta2ns(0x300, cd);
	clockevents_register_device(cd);		clockevents_register_device(cd);
			}

			static void __init hub_rt_clock_event_global_init(void)
			{
			unsigned int irq;

			do {
			smp_wmb();
			irq = rt_timer_irq;
			if (irq)
			break;

			irq = allocate_irqno();
			if (irq < 0)
			panic("Allocation of irq number for timer failed");
			} while (xchg(&rt_timer_irq, irq));

	set_irq_chip_and_handler(irq, &rt_irq_type, handle_percpu_irq);		set_irq_chip_and_handler(irq, &rt_irq_type, handle_percpu_irq);
	setup_irq(irq, &rt_irqaction);		setup_irq(irq, &hub_rt_irqaction);
	}		}

	static cycle_t hub_rt_read(void)		static cycle_t hub_rt_read(void)
	@@ -233,27 +238,29 @@ static cycle_t hub_rt_read(void)
	return REMOTE_HUB_L(cputonasid(0), PI_RT_COUNT);		return REMOTE_HUB_L(cputonasid(0), PI_RT_COUNT);
	}		}

	struct clocksource ht_rt_clocksource = {		struct clocksource hub_rt_clocksource = {
	.name = "HUB-RT",		.name = "HUB-RT",
	.rating = 200,		.rating = 200,
	.read = hub_rt_read,		.read = hub_rt_read,
	.mask = CLOCKSOURCE_MASK(52),		.mask = CLOCKSOURCE_MASK(52),
	.shift = 32,
	.flags = CLOCK_SOURCE_IS_CONTINUOUS,		.flags = CLOCK_SOURCE_IS_CONTINUOUS,
	};		};

	static void __init ip27_rt_clocksource_init(void)		static void __init hub_rt_clocksource_init(void)
	{		{
	clocksource_register(&ht_rt_clocksource);		struct clocksource *cs = &hub_rt_clocksource;

			clocksource_set_clock(cs, CYCLES_PER_SEC);
			clocksource_register(cs);
	}		}

	void __init plat_time_init(void)		void __init plat_time_init(void)
	{		{
	ip27_rt_clock_event_init();		hub_rt_clocksource_init();
	ip27_rt_clocksource_init();		hub_rt_clock_event_global_init();
	}		}

	void __init cpu_time_init(void)		void __cpuinit cpu_time_init(void)
	{		{
	lboard_t *board;		lboard_t *board;
	klcpu_t *cpu;		klcpu_t *cpu;
	@@ -271,6 +278,7 @@ void __init cpu_time_init(void)

	printk("CPU %d clock is %dMHz.\n", smp_processor_id(), cpu->cpu_speed);		printk("CPU %d clock is %dMHz.\n", smp_processor_id(), cpu->cpu_speed);

			hub_rt_clock_event_init();
	set_c0_status(SRB_TIMOCLK);		set_c0_status(SRB_TIMOCLK);
	}		}