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/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> 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 29 #define TICK_SIZE (tick_nsec / 1000) 30 31 #if 0 32 static 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 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> 82 83 unsigned long read_persistent_clock(void) 84 { 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 114 static void enable_rt_irq(unsigned int irq) 115 { 116 } 117 118 static void disable_rt_irq(unsigned int irq) 119 { 120 } 121 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, 129 }; 130 131 static int rt_next_event(unsigned long delta, struct clock_event_device *evt) 132 { 133 unsigned int cpu = smp_processor_id(); 134 int slice = cputoslice(cpu) == 0; 135 unsigned long cnt; 136 137 cnt = LOCAL_HUB_L(PI_RT_COUNT); 138 cnt += delta; 139 LOCAL_HUB_S(slice ? PI_RT_COMPARE_A : PI_RT_COMPARE_B, cnt); 140 141 return LOCAL_HUB_L(PI_RT_COUNT) >= cnt ? -ETIME : 0; 142 } 143 144 static 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 161 unsigned int rt_timer_irq; 162 163 static irqreturn_t hub_rt_counter_handler(int irq, void *dev_id) 164 { 165 struct clock_event_device *cd = dev_id; 166 unsigned int cpu = smp_processor_id(); 167 int slice = cputoslice(cpu) == 0; 168 169 LOCAL_HUB_S(slice ? PI_RT_PEND_A : PI_RT_PEND_B, 0); /* Ack */ 170 cd->event_handler(cd); 171 172 return IRQ_HANDLED; 173 } 174 175 struct irqaction hub_rt_irqaction = { 176 .handler = hub_rt_counter_handler, 177 .flags = IRQF_DISABLED | IRQF_PERCPU, 178 .name = "hub-rt", 179 }; 180 181 /* 182 * This is a hack; we really need to figure these values out dynamically 183 * 184 * Since 800 ns works very well with various HUB frequencies, such as 185 * 360, 380, 390 and 400 MHZ, we use 800 ns rtc cycle time. 186 * 187 * Ralf: which clock rate is used to feed the counter? 188 */ 189 #define NSEC_PER_CYCLE 800 190 #define CYCLES_PER_SEC (NSEC_PER_SEC / NSEC_PER_CYCLE) 191 192 static DEFINE_PER_CPU(struct clock_event_device, hub_rt_clockevent); 193 static DEFINE_PER_CPU(char [11], hub_rt_name); 194 195 static void __cpuinit hub_rt_clock_event_init(void) 196 { 197 unsigned int cpu = smp_processor_id(); 198 struct clock_event_device *cd = &per_cpu(hub_rt_clockevent, cpu); 199 unsigned char *name = per_cpu(hub_rt_name, cpu); 200 int irq = rt_timer_irq; 201 202 sprintf(name, "hub-rt %d", cpu); 203 cd->name = "HUB-RT", 204 cd->features = CLOCK_EVT_FEAT_ONESHOT, 205 clockevent_set_clock(cd, CYCLES_PER_SEC); 206 cd->max_delta_ns = clockevent_delta2ns(0xfffffffffffff, cd); 207 cd->min_delta_ns = clockevent_delta2ns(0x300, cd); 208 cd->rating = 200, 209 cd->irq = irq, 210 cd->cpumask = cpumask_of_cpu(cpu), 211 cd->rating = 300, 212 cd->set_next_event = rt_next_event, 213 cd->set_mode = rt_set_mode, 214 clockevents_register_device(cd); 215 } 216 217 static void __init hub_rt_clock_event_global_init(void) 218 { 219 unsigned int irq; 220 221 do { 222 smp_wmb(); 223 irq = rt_timer_irq; 224 if (irq) 225 break; 226 227 irq = allocate_irqno(); 228 if (irq < 0) 229 panic("Allocation of irq number for timer failed"); 230 } while (xchg(&rt_timer_irq, irq)); 231 232 set_irq_chip_and_handler(irq, &rt_irq_type, handle_percpu_irq); 233 setup_irq(irq, &hub_rt_irqaction); 234 } 235 236 static cycle_t hub_rt_read(void) 237 { 238 return REMOTE_HUB_L(cputonasid(0), PI_RT_COUNT); 239 } 240 241 struct clocksource hub_rt_clocksource = { 242 .name = "HUB-RT", 243 .rating = 200, 244 .read = hub_rt_read, 245 .mask = CLOCKSOURCE_MASK(52), 246 .flags = CLOCK_SOURCE_IS_CONTINUOUS, 247 }; 248 249 static void __init hub_rt_clocksource_init(void) 250 { 251 struct clocksource *cs = &hub_rt_clocksource; 252 253 clocksource_set_clock(cs, CYCLES_PER_SEC); 254 clocksource_register(cs); 255 } 256 257 void __init plat_time_init(void) 258 { 259 hub_rt_clocksource_init(); 260 hub_rt_clock_event_global_init(); 261 } 262 263 void __cpuinit cpu_time_init(void) 264 { 265 lboard_t *board; 266 klcpu_t *cpu; 267 int cpuid; 268 269 /* Don't use ARCS. ARCS is fragile. Klconfig is simple and sane. */ 270 board = find_lboard(KL_CONFIG_INFO(get_nasid()), KLTYPE_IP27); 271 if (!board) 272 panic("Can't find board info for myself."); 273 274 cpuid = LOCAL_HUB_L(PI_CPU_NUM) ? IP27_CPU0_INDEX : IP27_CPU1_INDEX; 275 cpu = (klcpu_t *) KLCF_COMP(board, cpuid); 276 if (!cpu) 277 panic("No information about myself?"); 278 279 printk("CPU %d clock is %dMHz.\n", smp_processor_id(), cpu->cpu_speed); 280 281 hub_rt_clock_event_init(); 282 set_c0_status(SRB_TIMOCLK); 283 } 284 285 void __init hub_rtc_init(cnodeid_t cnode) 286 { 287 /* 288 * We only need to initialize the current node. 289 * If this is not the current node then it is a cpuless 290 * node and timeouts will not happen there. 291 */ 292 if (get_compact_nodeid() == cnode) { 293 LOCAL_HUB_S(PI_RT_EN_A, 1); 294 LOCAL_HUB_S(PI_RT_EN_B, 1); 295 LOCAL_HUB_S(PI_PROF_EN_A, 0); 296 LOCAL_HUB_S(PI_PROF_EN_B, 0); 297 LOCAL_HUB_S(PI_RT_COUNT, 0); 298 LOCAL_HUB_S(PI_RT_PEND_A, 0); 299 LOCAL_HUB_S(PI_RT_PEND_B, 0); 300 } 301 } 302