2 * Copytight (C) 1999, 2000, 05, 06 Ralf Baechle (ralf@linux-mips.org)
3 * Copytight (C) 1999, 2000 Silicon Graphics, Inc.
6 #include <linux/clockchips.h>
7 #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>
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>
29 #define TICK_SIZE (tick_nsec / 1000)
32 static int set_rtc_mmss(unsigned long nowtime
)
35 int real_seconds
, real_minutes
, cmos_minutes
;
36 struct m48t35_rtc
*rtc
;
40 rtc
= (struct m48t35_rtc
*)(KL_CONFIG_CH_CONS_INFO(nid
)->memory_base
+
43 rtc
->control
|= M48T35_RTC_READ
;
44 cmos_minutes
= BCD2BIN(rtc
->min
);
45 rtc
->control
&= ~M48T35_RTC_READ
;
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
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 */
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
;
67 "set_rtc_mmss: can't update from %d to %d\n",
68 cmos_minutes
, real_minutes
);
76 /* 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>
83 unsigned long read_persistent_clock(void)
85 unsigned int year
, month
, date
, hour
, min
, sec
;
86 struct m48t35_rtc
*rtc
;
90 rtc
= (struct m48t35_rtc
*)(KL_CONFIG_CH_CONS_INFO(nid
)->memory_base
+
93 rtc
->control
|= M48T35_RTC_READ
;
100 rtc
->control
&= ~M48T35_RTC_READ
;
104 hour
= BCD2BIN(hour
);
105 date
= BCD2BIN(date
);
106 month
= BCD2BIN(month
);
107 year
= BCD2BIN(year
);
111 return mktime(year
, month
, date
, hour
, min
, sec
);
114 static void enable_rt_irq(unsigned int irq
)
118 static void disable_rt_irq(unsigned int irq
)
122 static struct irq_chip rt_irq_type
= {
123 .name
= "SN HUB RT timer",
124 .ack
= disable_rt_irq
,
125 .mask
= disable_rt_irq
,
126 .mask_ack
= disable_rt_irq
,
127 .unmask
= enable_rt_irq
,
128 .eoi
= enable_rt_irq
,
131 static int rt_next_event(unsigned long delta
, struct clock_event_device
*evt
)
133 unsigned int cpu
= smp_processor_id();
134 int slice
= cputoslice(cpu
);
137 cnt
= LOCAL_HUB_L(PI_RT_COUNT
);
139 LOCAL_HUB_S(PI_RT_COMPARE_A
+ PI_COUNT_OFFSET
* slice
, cnt
);
141 return LOCAL_HUB_L(PI_RT_COUNT
) >= cnt
? -ETIME
: 0;
144 static void rt_set_mode(enum clock_event_mode mode
,
145 struct clock_event_device
*evt
)
148 case CLOCK_EVT_MODE_ONESHOT
:
149 /* The only mode supported */
152 case CLOCK_EVT_MODE_PERIODIC
:
153 case CLOCK_EVT_MODE_UNUSED
:
154 case CLOCK_EVT_MODE_SHUTDOWN
:
155 case CLOCK_EVT_MODE_RESUME
:
161 unsigned int rt_timer_irq
;
163 static irqreturn_t
hub_rt_counter_handler(int irq
, void *dev_id
)
165 struct clock_event_device
*cd
= dev_id
;
166 unsigned int cpu
= smp_processor_id();
167 int slice
= cputoslice(cpu
);
172 LOCAL_HUB_S(PI_RT_PEND_A
+ PI_COUNT_OFFSET
* slice
, 0);
173 cd
->event_handler(cd
);
178 struct irqaction hub_rt_irqaction
= {
179 .handler
= hub_rt_counter_handler
,
180 .flags
= IRQF_DISABLED
| IRQF_PERCPU
,
185 * This is a hack; we really need to figure these values out dynamically
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.
190 * Ralf: which clock rate is used to feed the counter?
192 #define NSEC_PER_CYCLE 800
193 #define CYCLES_PER_SEC (NSEC_PER_SEC / NSEC_PER_CYCLE)
195 static DEFINE_PER_CPU(struct clock_event_device
, hub_rt_clockevent
);
196 static DEFINE_PER_CPU(char [11], hub_rt_name
);
198 static void __cpuinit
hub_rt_clock_event_init(void)
200 unsigned int cpu
= smp_processor_id();
201 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
;
205 sprintf(name
, "hub-rt %d", cpu
);
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
);
213 cd
->cpumask
= cpumask_of_cpu(cpu
),
215 cd
->set_next_event
= rt_next_event
,
216 cd
->set_mode
= rt_set_mode
,
217 clockevents_register_device(cd
);
220 static void __init
hub_rt_clock_event_global_init(void)
230 irq
= allocate_irqno();
232 panic("Allocation of irq number for timer failed");
233 } while (xchg(&rt_timer_irq
, irq
));
235 set_irq_chip_and_handler(irq
, &rt_irq_type
, handle_percpu_irq
);
236 setup_irq(irq
, &hub_rt_irqaction
);
239 static cycle_t
hub_rt_read(void)
241 return REMOTE_HUB_L(cputonasid(0), PI_RT_COUNT
);
244 struct clocksource hub_rt_clocksource
= {
248 .mask
= CLOCKSOURCE_MASK(52),
249 .flags
= CLOCK_SOURCE_IS_CONTINUOUS
,
252 static void __init
hub_rt_clocksource_init(void)
254 struct clocksource
*cs
= &hub_rt_clocksource
;
256 clocksource_set_clock(cs
, CYCLES_PER_SEC
);
257 clocksource_register(cs
);
260 void __init
plat_time_init(void)
262 hub_rt_clocksource_init();
263 hub_rt_clock_event_global_init();
266 void __cpuinit
cpu_time_init(void)
272 /* Don't use ARCS. ARCS is fragile. Klconfig is simple and sane. */
273 board
= find_lboard(KL_CONFIG_INFO(get_nasid()), KLTYPE_IP27
);
275 panic("Can't find board info for myself.");
277 cpuid
= LOCAL_HUB_L(PI_CPU_NUM
) ? IP27_CPU0_INDEX
: IP27_CPU1_INDEX
;
278 cpu
= (klcpu_t
*) KLCF_COMP(board
, cpuid
);
280 panic("No information about myself?");
282 printk("CPU %d clock is %dMHz.\n", smp_processor_id(), cpu
->cpu_speed
);
284 hub_rt_clock_event_init();
285 set_c0_status(SRB_TIMOCLK
);
288 void __cpuinit
hub_rtc_init(cnodeid_t cnode
)
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.
295 if (get_compact_nodeid() == cnode
) {
296 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);
300 LOCAL_HUB_S(PI_RT_COUNT
, 0);
301 LOCAL_HUB_S(PI_RT_PEND_A
, 0);
302 LOCAL_HUB_S(PI_RT_PEND_B
, 0);