1 /* 2 * Copytight (C) 1999, 2000, 05, 06 Ralf Baechle (ralf@linux-mips.org) 3 * Copytight (C) 1999, 2000 Silicon Graphics, Inc. 4 */ 5 #include <linux/bcd.h> 6 #include <linux/init.h> 7 #include <linux/kernel.h> 8 #include <linux/sched.h> 9 #include <linux/interrupt.h> 10 #include <linux/kernel_stat.h> 11 #include <linux/param.h> 12 #include <linux/time.h> 13 #include <linux/timex.h> 14 #include <linux/mm.h> 15 16 #include <asm/time.h> 17 #include <asm/pgtable.h> 18 #include <asm/sgialib.h> 19 #include <asm/sn/ioc3.h> 20 #include <asm/m48t35.h> 21 #include <asm/sn/klconfig.h> 22 #include <asm/sn/arch.h> 23 #include <asm/sn/addrs.h> 24 #include <asm/sn/sn_private.h> 25 #include <asm/sn/sn0/ip27.h> 26 #include <asm/sn/sn0/hub.h> 27 28 /* 29 * This is a hack; we really need to figure these values out dynamically 30 * 31 * Since 800 ns works very well with various HUB frequencies, such as 32 * 360, 380, 390 and 400 MHZ, we use 800 ns rtc cycle time. 33 * 34 * Ralf: which clock rate is used to feed the counter? 35 */ 36 #define NSEC_PER_CYCLE 800 37 #define CYCLES_PER_SEC (NSEC_PER_SEC/NSEC_PER_CYCLE) 38 #define CYCLES_PER_JIFFY (CYCLES_PER_SEC/HZ) 39 40 #define TICK_SIZE (tick_nsec / 1000) 41 42 static unsigned long ct_cur[NR_CPUS]; /* What counter should be at next timer irq */ 43 static long last_rtc_update; /* Last time the rtc clock got updated */ 44 45 #if 0 46 static int set_rtc_mmss(unsigned long nowtime) 47 { 48 int retval = 0; 49 int real_seconds, real_minutes, cmos_minutes; 50 struct m48t35_rtc *rtc; 51 nasid_t nid; 52 53 nid = get_nasid(); 54 rtc = (struct m48t35_rtc *)(KL_CONFIG_CH_CONS_INFO(nid)->memory_base + 55 IOC3_BYTEBUS_DEV0); 56 57 rtc->control |= M48T35_RTC_READ; 58 cmos_minutes = BCD2BIN(rtc->min); 59 rtc->control &= ~M48T35_RTC_READ; 60 61 /* 62 * Since we're only adjusting minutes and seconds, don't interfere with 63 * hour overflow. This avoids messing with unknown time zones but 64 * requires your RTC not to be off by more than 15 minutes 65 */ 66 real_seconds = nowtime % 60; 67 real_minutes = nowtime / 60; 68 if (((abs(real_minutes - cmos_minutes) + 15)/30) & 1) 69 real_minutes += 30; /* correct for half hour time zone */ 70 real_minutes %= 60; 71 72 if (abs(real_minutes - cmos_minutes) < 30) { 73 real_seconds = BIN2BCD(real_seconds); 74 real_minutes = BIN2BCD(real_minutes); 75 rtc->control |= M48T35_RTC_SET; 76 rtc->sec = real_seconds; 77 rtc->min = real_minutes; 78 rtc->control &= ~M48T35_RTC_SET; 79 } else { 80 printk(KERN_WARNING 81 "set_rtc_mmss: can't update from %d to %d\n", 82 cmos_minutes, real_minutes); 83 retval = -1; 84 } 85 86 return retval; 87 } 88 #endif 89 90 static unsigned int rt_timer_irq; 91 92 void ip27_rt_timer_interrupt(void) 93 { 94 int cpu = smp_processor_id(); 95 int cpuA = cputoslice(cpu) == 0; 96 unsigned int irq = rt_timer_irq; 97 98 irq_enter(); 99 write_seqlock(&xtime_lock); 100 101 again: 102 LOCAL_HUB_S(cpuA ? PI_RT_PEND_A : PI_RT_PEND_B, 0); /* Ack */ 103 ct_cur[cpu] += CYCLES_PER_JIFFY; 104 LOCAL_HUB_S(cpuA ? PI_RT_COMPARE_A : PI_RT_COMPARE_B, ct_cur[cpu]); 105 106 if (LOCAL_HUB_L(PI_RT_COUNT) >= ct_cur[cpu]) 107 goto again; 108 109 kstat_this_cpu.irqs[irq]++; /* kstat only for bootcpu? */ 110 111 if (cpu == 0) 112 do_timer(1); 113 114 update_process_times(user_mode(get_irq_regs())); 115 116 /* 117 * If we have an externally synchronized Linux clock, then update 118 * RTC clock accordingly every ~11 minutes. Set_rtc_mmss() has to be 119 * called as close as possible to when a second starts. 120 */ 121 if (ntp_synced() && 122 xtime.tv_sec > last_rtc_update + 660 && 123 (xtime.tv_nsec / 1000) >= 500000 - ((unsigned) TICK_SIZE) / 2 && 124 (xtime.tv_nsec / 1000) <= 500000 + ((unsigned) TICK_SIZE) / 2) { 125 if (rtc_mips_set_time(xtime.tv_sec) == 0) { 126 last_rtc_update = xtime.tv_sec; 127 } else { 128 last_rtc_update = xtime.tv_sec - 600; 129 /* do it again in 60 s */ 130 } 131 } 132 133 write_sequnlock(&xtime_lock); 134 irq_exit(); 135 } 136 137 unsigned long ip27_do_gettimeoffset(void) 138 { 139 unsigned long ct_cur1; 140 ct_cur1 = REMOTE_HUB_L(cputonasid(0), PI_RT_COUNT) + CYCLES_PER_JIFFY; 141 return (ct_cur1 - ct_cur[0]) * NSEC_PER_CYCLE / 1000; 142 } 143 144 /* Includes for ioc3_init(). */ 145 #include <asm/sn/types.h> 146 #include <asm/sn/sn0/addrs.h> 147 #include <asm/sn/sn0/hubni.h> 148 #include <asm/sn/sn0/hubio.h> 149 #include <asm/pci/bridge.h> 150 151 static __init unsigned long get_m48t35_time(void) 152 { 153 unsigned int year, month, date, hour, min, sec; 154 struct m48t35_rtc *rtc; 155 nasid_t nid; 156 157 nid = get_nasid(); 158 rtc = (struct m48t35_rtc *)(KL_CONFIG_CH_CONS_INFO(nid)->memory_base + 159 IOC3_BYTEBUS_DEV0); 160 161 rtc->control |= M48T35_RTC_READ; 162 sec = rtc->sec; 163 min = rtc->min; 164 hour = rtc->hour; 165 date = rtc->date; 166 month = rtc->month; 167 year = rtc->year; 168 rtc->control &= ~M48T35_RTC_READ; 169 170 sec = BCD2BIN(sec); 171 min = BCD2BIN(min); 172 hour = BCD2BIN(hour); 173 date = BCD2BIN(date); 174 month = BCD2BIN(month); 175 year = BCD2BIN(year); 176 177 year += 1970; 178 179 return mktime(year, month, date, hour, min, sec); 180 } 181 182 static unsigned int startup_rt_irq(unsigned int irq) 183 { 184 return 0; 185 } 186 187 static void shutdown_rt_irq(unsigned int irq) 188 { 189 } 190 191 static void enable_rt_irq(unsigned int irq) 192 { 193 } 194 195 static void disable_rt_irq(unsigned int irq) 196 { 197 } 198 199 static void mask_and_ack_rt(unsigned int irq) 200 { 201 } 202 203 static void end_rt_irq(unsigned int irq) 204 { 205 } 206 207 static struct irq_chip rt_irq_type = { 208 .typename = "SN HUB RT timer", 209 .startup = startup_rt_irq, 210 .shutdown = shutdown_rt_irq, 211 .enable = enable_rt_irq, 212 .disable = disable_rt_irq, 213 .ack = mask_and_ack_rt, 214 .end = end_rt_irq, 215 }; 216 217 static struct irqaction rt_irqaction = { 218 .handler = ip27_rt_timer_interrupt, 219 .flags = IRQF_DISABLED, 220 .mask = CPU_MASK_NONE, 221 .name = "timer" 222 }; 223 224 extern int allocate_irqno(void); 225 226 void __init plat_timer_setup(struct irqaction *irq) 227 { 228 int irqno = allocate_irqno(); 229 230 if (irqno < 0) 231 panic("Can't allocate interrupt number for timer interrupt"); 232 233 irq_desc[irqno].status = IRQ_DISABLED; 234 irq_desc[irqno].action = NULL; 235 irq_desc[irqno].depth = 1; 236 irq_desc[irqno].chip = &rt_irq_type; 237 238 /* over-write the handler, we use our own way */ 239 irq->handler = no_action; 240 241 /* setup irqaction */ 242 irq_desc[irqno].status |= IRQ_PER_CPU; 243 244 rt_timer_irq = irqno; 245 /* 246 * Only needed to get /proc/interrupt to display timer irq stats 247 */ 248 setup_irq(irqno, &rt_irqaction); 249 } 250 251 void __init ip27_time_init(void) 252 { 253 xtime.tv_sec = get_m48t35_time(); 254 xtime.tv_nsec = 0; 255 256 do_gettimeoffset = ip27_do_gettimeoffset; 257 } 258 259 void __init cpu_time_init(void) 260 { 261 lboard_t *board; 262 klcpu_t *cpu; 263 int cpuid; 264 265 /* Don't use ARCS. ARCS is fragile. Klconfig is simple and sane. */ 266 board = find_lboard(KL_CONFIG_INFO(get_nasid()), KLTYPE_IP27); 267 if (!board) 268 panic("Can't find board info for myself."); 269 270 cpuid = LOCAL_HUB_L(PI_CPU_NUM) ? IP27_CPU0_INDEX : IP27_CPU1_INDEX; 271 cpu = (klcpu_t *) KLCF_COMP(board, cpuid); 272 if (!cpu) 273 panic("No information about myself?"); 274 275 printk("CPU %d clock is %dMHz.\n", smp_processor_id(), cpu->cpu_speed); 276 277 set_c0_status(SRB_TIMOCLK); 278 } 279 280 void __init hub_rtc_init(cnodeid_t cnode) 281 { 282 /* 283 * We only need to initialize the current node. 284 * If this is not the current node then it is a cpuless 285 * node and timeouts will not happen there. 286 */ 287 if (get_compact_nodeid() == cnode) { 288 int cpu = smp_processor_id(); 289 LOCAL_HUB_S(PI_RT_EN_A, 1); 290 LOCAL_HUB_S(PI_RT_EN_B, 1); 291 LOCAL_HUB_S(PI_PROF_EN_A, 0); 292 LOCAL_HUB_S(PI_PROF_EN_B, 0); 293 ct_cur[cpu] = CYCLES_PER_JIFFY; 294 LOCAL_HUB_S(PI_RT_COMPARE_A, ct_cur[cpu]); 295 LOCAL_HUB_S(PI_RT_COUNT, 0); 296 LOCAL_HUB_S(PI_RT_PEND_A, 0); 297 LOCAL_HUB_S(PI_RT_COMPARE_B, ct_cur[cpu]); 298 LOCAL_HUB_S(PI_RT_COUNT, 0); 299 LOCAL_HUB_S(PI_RT_PEND_B, 0); 300 } 301 } 302