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 /* Includes for ioc3_init(). */ 138 #include <asm/sn/types.h> 139 #include <asm/sn/sn0/addrs.h> 140 #include <asm/sn/sn0/hubni.h> 141 #include <asm/sn/sn0/hubio.h> 142 #include <asm/pci/bridge.h> 143 144 static __init unsigned long get_m48t35_time(void) 145 { 146 unsigned int year, month, date, hour, min, sec; 147 struct m48t35_rtc *rtc; 148 nasid_t nid; 149 150 nid = get_nasid(); 151 rtc = (struct m48t35_rtc *)(KL_CONFIG_CH_CONS_INFO(nid)->memory_base + 152 IOC3_BYTEBUS_DEV0); 153 154 rtc->control |= M48T35_RTC_READ; 155 sec = rtc->sec; 156 min = rtc->min; 157 hour = rtc->hour; 158 date = rtc->date; 159 month = rtc->month; 160 year = rtc->year; 161 rtc->control &= ~M48T35_RTC_READ; 162 163 sec = BCD2BIN(sec); 164 min = BCD2BIN(min); 165 hour = BCD2BIN(hour); 166 date = BCD2BIN(date); 167 month = BCD2BIN(month); 168 year = BCD2BIN(year); 169 170 year += 1970; 171 172 return mktime(year, month, date, hour, min, sec); 173 } 174 175 static void enable_rt_irq(unsigned int irq) 176 { 177 } 178 179 static void disable_rt_irq(unsigned int irq) 180 { 181 } 182 183 static struct irq_chip rt_irq_type = { 184 .typename = "SN HUB RT timer", 185 .ack = disable_rt_irq, 186 .mask = disable_rt_irq, 187 .mask_ack = disable_rt_irq, 188 .unmask = enable_rt_irq, 189 .eoi = enable_rt_irq, 190 }; 191 192 static struct irqaction rt_irqaction = { 193 .handler = ip27_rt_timer_interrupt, 194 .flags = IRQF_DISABLED, 195 .mask = CPU_MASK_NONE, 196 .name = "timer" 197 }; 198 199 void __init plat_timer_setup(struct irqaction *irq) 200 { 201 int irqno = allocate_irqno(); 202 203 if (irqno < 0) 204 panic("Can't allocate interrupt number for timer interrupt"); 205 206 set_irq_chip_and_handler(irqno, &rt_irq_type, handle_percpu_irq); 207 208 /* over-write the handler, we use our own way */ 209 irq->handler = no_action; 210 211 /* setup irqaction */ 212 irq_desc[irqno].status |= IRQ_PER_CPU; 213 214 rt_timer_irq = irqno; 215 /* 216 * Only needed to get /proc/interrupt to display timer irq stats 217 */ 218 setup_irq(irqno, &rt_irqaction); 219 } 220 221 static cycle_t ip27_hpt_read(void) 222 { 223 return REMOTE_HUB_L(cputonasid(0), PI_RT_COUNT); 224 } 225 226 void __init ip27_time_init(void) 227 { 228 clocksource_mips.read = ip27_hpt_read; 229 mips_hpt_frequency = CYCLES_PER_SEC; 230 xtime.tv_sec = get_m48t35_time(); 231 xtime.tv_nsec = 0; 232 } 233 234 void __init cpu_time_init(void) 235 { 236 lboard_t *board; 237 klcpu_t *cpu; 238 int cpuid; 239 240 /* Don't use ARCS. ARCS is fragile. Klconfig is simple and sane. */ 241 board = find_lboard(KL_CONFIG_INFO(get_nasid()), KLTYPE_IP27); 242 if (!board) 243 panic("Can't find board info for myself."); 244 245 cpuid = LOCAL_HUB_L(PI_CPU_NUM) ? IP27_CPU0_INDEX : IP27_CPU1_INDEX; 246 cpu = (klcpu_t *) KLCF_COMP(board, cpuid); 247 if (!cpu) 248 panic("No information about myself?"); 249 250 printk("CPU %d clock is %dMHz.\n", smp_processor_id(), cpu->cpu_speed); 251 252 set_c0_status(SRB_TIMOCLK); 253 } 254 255 void __init hub_rtc_init(cnodeid_t cnode) 256 { 257 /* 258 * We only need to initialize the current node. 259 * If this is not the current node then it is a cpuless 260 * node and timeouts will not happen there. 261 */ 262 if (get_compact_nodeid() == cnode) { 263 int cpu = smp_processor_id(); 264 LOCAL_HUB_S(PI_RT_EN_A, 1); 265 LOCAL_HUB_S(PI_RT_EN_B, 1); 266 LOCAL_HUB_S(PI_PROF_EN_A, 0); 267 LOCAL_HUB_S(PI_PROF_EN_B, 0); 268 ct_cur[cpu] = CYCLES_PER_JIFFY; 269 LOCAL_HUB_S(PI_RT_COMPARE_A, ct_cur[cpu]); 270 LOCAL_HUB_S(PI_RT_COUNT, 0); 271 LOCAL_HUB_S(PI_RT_PEND_A, 0); 272 LOCAL_HUB_S(PI_RT_COMPARE_B, ct_cur[cpu]); 273 LOCAL_HUB_S(PI_RT_COUNT, 0); 274 LOCAL_HUB_S(PI_RT_PEND_B, 0); 275 } 276 } 277