blob: 08d45369be45c40a4895a00c9c831e109de9fd7f [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Ralf Baechle54d0a212006-07-09 21:38:56 +01002 * Copytight (C) 1999, 2000, 05, 06 Ralf Baechle (ralf@linux-mips.org)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 * Copytight (C) 1999, 2000 Silicon Graphics, Inc.
4 */
5#include <linux/bcd.h>
Ralf Baechlee887b242007-10-18 13:34:12 +01006#include <linux/clockchips.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07007#include <linux/init.h>
8#include <linux/kernel.h>
9#include <linux/sched.h>
10#include <linux/interrupt.h>
11#include <linux/kernel_stat.h>
12#include <linux/param.h>
13#include <linux/time.h>
14#include <linux/timex.h>
15#include <linux/mm.h>
16
17#include <asm/time.h>
18#include <asm/pgtable.h>
19#include <asm/sgialib.h>
20#include <asm/sn/ioc3.h>
21#include <asm/m48t35.h>
22#include <asm/sn/klconfig.h>
23#include <asm/sn/arch.h>
24#include <asm/sn/addrs.h>
25#include <asm/sn/sn_private.h>
26#include <asm/sn/sn0/ip27.h>
27#include <asm/sn/sn0/hub.h>
28
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#define TICK_SIZE (tick_nsec / 1000)
30
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#if 0
32static int set_rtc_mmss(unsigned long nowtime)
33{
34 int retval = 0;
35 int real_seconds, real_minutes, cmos_minutes;
36 struct m48t35_rtc *rtc;
37 nasid_t nid;
38
39 nid = get_nasid();
40 rtc = (struct m48t35_rtc *)(KL_CONFIG_CH_CONS_INFO(nid)->memory_base +
41 IOC3_BYTEBUS_DEV0);
42
43 rtc->control |= M48T35_RTC_READ;
44 cmos_minutes = BCD2BIN(rtc->min);
45 rtc->control &= ~M48T35_RTC_READ;
46
47 /*
48 * Since we're only adjusting minutes and seconds, don't interfere with
49 * hour overflow. This avoids messing with unknown time zones but
50 * requires your RTC not to be off by more than 15 minutes
51 */
52 real_seconds = nowtime % 60;
53 real_minutes = nowtime / 60;
54 if (((abs(real_minutes - cmos_minutes) + 15)/30) & 1)
55 real_minutes += 30; /* correct for half hour time zone */
56 real_minutes %= 60;
57
58 if (abs(real_minutes - cmos_minutes) < 30) {
59 real_seconds = BIN2BCD(real_seconds);
60 real_minutes = BIN2BCD(real_minutes);
61 rtc->control |= M48T35_RTC_SET;
62 rtc->sec = real_seconds;
63 rtc->min = real_minutes;
64 rtc->control &= ~M48T35_RTC_SET;
65 } else {
66 printk(KERN_WARNING
67 "set_rtc_mmss: can't update from %d to %d\n",
68 cmos_minutes, real_minutes);
69 retval = -1;
70 }
71
72 return retval;
73}
74#endif
75
Linus Torvalds1da177e2005-04-16 15:20:36 -070076/* Includes for ioc3_init(). */
77#include <asm/sn/types.h>
78#include <asm/sn/sn0/addrs.h>
79#include <asm/sn/sn0/hubni.h>
80#include <asm/sn/sn0/hubio.h>
81#include <asm/pci/bridge.h>
82
Ralf Baechle4b550482007-10-11 23:46:08 +010083unsigned long read_persistent_clock(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -070084{
85 unsigned int year, month, date, hour, min, sec;
86 struct m48t35_rtc *rtc;
87 nasid_t nid;
88
89 nid = get_nasid();
90 rtc = (struct m48t35_rtc *)(KL_CONFIG_CH_CONS_INFO(nid)->memory_base +
91 IOC3_BYTEBUS_DEV0);
92
93 rtc->control |= M48T35_RTC_READ;
94 sec = rtc->sec;
95 min = rtc->min;
96 hour = rtc->hour;
97 date = rtc->date;
98 month = rtc->month;
99 year = rtc->year;
100 rtc->control &= ~M48T35_RTC_READ;
101
102 sec = BCD2BIN(sec);
103 min = BCD2BIN(min);
104 hour = BCD2BIN(hour);
105 date = BCD2BIN(date);
106 month = BCD2BIN(month);
107 year = BCD2BIN(year);
108
109 year += 1970;
110
111 return mktime(year, month, date, hour, min, sec);
112}
113
Ralf Baechle3c009442006-06-16 17:10:49 +0200114static void enable_rt_irq(unsigned int irq)
115{
116}
117
118static void disable_rt_irq(unsigned int irq)
119{
120}
121
Ralf Baechle94dee172006-07-02 14:41:42 +0100122static struct irq_chip rt_irq_type = {
Atsushi Nemoto70d21cd2007-01-15 00:07:25 +0900123 .name = "SN HUB RT timer",
Atsushi Nemoto1603b5a2006-11-02 02:08:36 +0900124 .ack = disable_rt_irq,
125 .mask = disable_rt_irq,
126 .mask_ack = disable_rt_irq,
127 .unmask = enable_rt_irq,
Atsushi Nemoto14178362006-11-14 01:13:18 +0900128 .eoi = enable_rt_irq,
Ralf Baechle3c009442006-06-16 17:10:49 +0200129};
130
Ralf Baechle06d428d2007-10-22 10:34:13 +0100131static int rt_next_event(unsigned long delta, struct clock_event_device *evt)
132{
133 unsigned int cpu = smp_processor_id();
Ralf Baechlec8925292007-11-01 12:20:51 +0000134 int slice = cputoslice(cpu);
Ralf Baechle06d428d2007-10-22 10:34:13 +0100135 unsigned long cnt;
136
137 cnt = LOCAL_HUB_L(PI_RT_COUNT);
138 cnt += delta;
Ralf Baechle725d7b362007-10-28 23:02:37 +0000139 LOCAL_HUB_S(PI_RT_COMPARE_A + PI_COUNT_OFFSET * slice, cnt);
Ralf Baechle06d428d2007-10-22 10:34:13 +0100140
141 return LOCAL_HUB_L(PI_RT_COUNT) >= cnt ? -ETIME : 0;
142}
143
144static void rt_set_mode(enum clock_event_mode mode,
145 struct clock_event_device *evt)
146{
147 switch (mode) {
148 case CLOCK_EVT_MODE_ONESHOT:
149 /* The only mode supported */
150 break;
151
152 case CLOCK_EVT_MODE_PERIODIC:
153 case CLOCK_EVT_MODE_UNUSED:
154 case CLOCK_EVT_MODE_SHUTDOWN:
155 case CLOCK_EVT_MODE_RESUME:
156 /* Nothing to do */
157 break;
158 }
159}
160
Ralf Baechlee887b242007-10-18 13:34:12 +0100161unsigned int rt_timer_irq;
162
Ralf Baechle06d428d2007-10-22 10:34:13 +0100163static irqreturn_t hub_rt_counter_handler(int irq, void *dev_id)
Ralf Baechlee887b242007-10-18 13:34:12 +0100164{
Ralf Baechle06d428d2007-10-22 10:34:13 +0100165 struct clock_event_device *cd = dev_id;
Ralf Baechlee887b242007-10-18 13:34:12 +0100166 unsigned int cpu = smp_processor_id();
Ralf Baechle725d7b362007-10-28 23:02:37 +0000167 int slice = cputoslice(cpu);
Ralf Baechlee887b242007-10-18 13:34:12 +0100168
Ralf Baechle725d7b362007-10-28 23:02:37 +0000169 /*
170 * Ack
171 */
Ralf Baechlec8925292007-11-01 12:20:51 +0000172 LOCAL_HUB_S(PI_RT_PEND_A + PI_COUNT_OFFSET * slice, 0);
Ralf Baechlee887b242007-10-18 13:34:12 +0100173 cd->event_handler(cd);
174
175 return IRQ_HANDLED;
176}
177
Ralf Baechle06d428d2007-10-22 10:34:13 +0100178struct irqaction hub_rt_irqaction = {
179 .handler = hub_rt_counter_handler,
180 .flags = IRQF_DISABLED | IRQF_PERCPU,
181 .name = "hub-rt",
Ralf Baechle3c009442006-06-16 17:10:49 +0200182};
183
Ralf Baechlee887b242007-10-18 13:34:12 +0100184/*
185 * This is a hack; we really need to figure these values out dynamically
186 *
187 * Since 800 ns works very well with various HUB frequencies, such as
188 * 360, 380, 390 and 400 MHZ, we use 800 ns rtc cycle time.
189 *
190 * Ralf: which clock rate is used to feed the counter?
191 */
192#define NSEC_PER_CYCLE 800
193#define CYCLES_PER_SEC (NSEC_PER_SEC / NSEC_PER_CYCLE)
Ralf Baechle3c009442006-06-16 17:10:49 +0200194
Ralf Baechle06d428d2007-10-22 10:34:13 +0100195static DEFINE_PER_CPU(struct clock_event_device, hub_rt_clockevent);
196static DEFINE_PER_CPU(char [11], hub_rt_name);
197
198static void __cpuinit hub_rt_clock_event_init(void)
Ralf Baechlee887b242007-10-18 13:34:12 +0100199{
Ralf Baechlee887b242007-10-18 13:34:12 +0100200 unsigned int cpu = smp_processor_id();
Ralf Baechle06d428d2007-10-22 10:34:13 +0100201 struct clock_event_device *cd = &per_cpu(hub_rt_clockevent, cpu);
202 unsigned char *name = per_cpu(hub_rt_name, cpu);
203 int irq = rt_timer_irq;
Ralf Baechlee887b242007-10-18 13:34:12 +0100204
Ralf Baechle06d428d2007-10-22 10:34:13 +0100205 sprintf(name, "hub-rt %d", cpu);
206 cd->name = "HUB-RT",
207 cd->features = CLOCK_EVT_FEAT_ONESHOT,
208 clockevent_set_clock(cd, CYCLES_PER_SEC);
209 cd->max_delta_ns = clockevent_delta2ns(0xfffffffffffff, cd);
210 cd->min_delta_ns = clockevent_delta2ns(0x300, cd);
211 cd->rating = 200,
Ralf Baechlee887b242007-10-18 13:34:12 +0100212 cd->irq = irq,
213 cd->cpumask = cpumask_of_cpu(cpu),
Ralf Baechle06d428d2007-10-22 10:34:13 +0100214 cd->rating = 300,
215 cd->set_next_event = rt_next_event,
216 cd->set_mode = rt_set_mode,
Ralf Baechlee887b242007-10-18 13:34:12 +0100217 clockevents_register_device(cd);
Ralf Baechle06d428d2007-10-22 10:34:13 +0100218}
219
220static void __init hub_rt_clock_event_global_init(void)
221{
222 unsigned int irq;
223
224 do {
225 smp_wmb();
226 irq = rt_timer_irq;
227 if (irq)
228 break;
229
230 irq = allocate_irqno();
231 if (irq < 0)
232 panic("Allocation of irq number for timer failed");
233 } while (xchg(&rt_timer_irq, irq));
Ralf Baechlee887b242007-10-18 13:34:12 +0100234
235 set_irq_chip_and_handler(irq, &rt_irq_type, handle_percpu_irq);
Ralf Baechle06d428d2007-10-22 10:34:13 +0100236 setup_irq(irq, &hub_rt_irqaction);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237}
238
Ralf Baechle87b23352007-10-11 23:46:10 +0100239static cycle_t hub_rt_read(void)
Atsushi Nemoto16b7b2a2006-10-24 00:21:27 +0900240{
241 return REMOTE_HUB_L(cputonasid(0), PI_RT_COUNT);
242}
243
Ralf Baechle06d428d2007-10-22 10:34:13 +0100244struct clocksource hub_rt_clocksource = {
Ralf Baechlee887b242007-10-18 13:34:12 +0100245 .name = "HUB-RT",
Ralf Baechle87b23352007-10-11 23:46:10 +0100246 .rating = 200,
247 .read = hub_rt_read,
248 .mask = CLOCKSOURCE_MASK(52),
Ralf Baechle87b23352007-10-11 23:46:10 +0100249 .flags = CLOCK_SOURCE_IS_CONTINUOUS,
250};
251
Ralf Baechle06d428d2007-10-22 10:34:13 +0100252static void __init hub_rt_clocksource_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253{
Ralf Baechle06d428d2007-10-22 10:34:13 +0100254 struct clocksource *cs = &hub_rt_clocksource;
255
256 clocksource_set_clock(cs, CYCLES_PER_SEC);
257 clocksource_register(cs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258}
259
Ralf Baechlee887b242007-10-18 13:34:12 +0100260void __init plat_time_init(void)
261{
Ralf Baechle06d428d2007-10-22 10:34:13 +0100262 hub_rt_clocksource_init();
263 hub_rt_clock_event_global_init();
Ralf Baechlee887b242007-10-18 13:34:12 +0100264}
265
Ralf Baechle06d428d2007-10-22 10:34:13 +0100266void __cpuinit cpu_time_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267{
268 lboard_t *board;
269 klcpu_t *cpu;
270 int cpuid;
271
272 /* Don't use ARCS. ARCS is fragile. Klconfig is simple and sane. */
273 board = find_lboard(KL_CONFIG_INFO(get_nasid()), KLTYPE_IP27);
274 if (!board)
275 panic("Can't find board info for myself.");
276
277 cpuid = LOCAL_HUB_L(PI_CPU_NUM) ? IP27_CPU0_INDEX : IP27_CPU1_INDEX;
278 cpu = (klcpu_t *) KLCF_COMP(board, cpuid);
279 if (!cpu)
280 panic("No information about myself?");
281
282 printk("CPU %d clock is %dMHz.\n", smp_processor_id(), cpu->cpu_speed);
283
Ralf Baechle06d428d2007-10-22 10:34:13 +0100284 hub_rt_clock_event_init();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 set_c0_status(SRB_TIMOCLK);
286}
287
288void __init hub_rtc_init(cnodeid_t cnode)
289{
290 /*
291 * We only need to initialize the current node.
292 * If this is not the current node then it is a cpuless
293 * node and timeouts will not happen there.
294 */
295 if (get_compact_nodeid() == cnode) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 LOCAL_HUB_S(PI_RT_EN_A, 1);
297 LOCAL_HUB_S(PI_RT_EN_B, 1);
298 LOCAL_HUB_S(PI_PROF_EN_A, 0);
299 LOCAL_HUB_S(PI_PROF_EN_B, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 LOCAL_HUB_S(PI_RT_COUNT, 0);
301 LOCAL_HUB_S(PI_RT_PEND_A, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 LOCAL_HUB_S(PI_RT_PEND_B, 0);
303 }
304}