Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
Ralf Baechle | 54d0a21 | 2006-07-09 21:38:56 +0100 | [diff] [blame] | 2 | * Copytight (C) 1999, 2000, 05, 06 Ralf Baechle (ralf@linux-mips.org) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3 | * Copytight (C) 1999, 2000 Silicon Graphics, Inc. |
| 4 | */ |
| 5 | #include <linux/bcd.h> |
Ralf Baechle | e887b24 | 2007-10-18 13:34:12 +0100 | [diff] [blame] | 6 | #include <linux/clockchips.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 7 | #include <linux/init.h> |
| 8 | #include <linux/kernel.h> |
| 9 | #include <linux/sched.h> |
Deng-Cheng Zhu | c41cef3 | 2015-03-07 10:30:29 -0800 | [diff] [blame] | 10 | #include <linux/sched_clock.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 11 | #include <linux/interrupt.h> |
| 12 | #include <linux/kernel_stat.h> |
| 13 | #include <linux/param.h> |
Ralf Baechle | 631330f | 2009-06-19 14:05:26 +0100 | [diff] [blame] | 14 | #include <linux/smp.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 15 | #include <linux/time.h> |
| 16 | #include <linux/timex.h> |
| 17 | #include <linux/mm.h> |
Thomas Bogendoerfer | 3ec066c | 2008-10-14 17:17:28 +0200 | [diff] [blame] | 18 | #include <linux/platform_device.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 19 | |
| 20 | #include <asm/time.h> |
| 21 | #include <asm/pgtable.h> |
| 22 | #include <asm/sgialib.h> |
| 23 | #include <asm/sn/ioc3.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 24 | #include <asm/sn/klconfig.h> |
| 25 | #include <asm/sn/arch.h> |
| 26 | #include <asm/sn/addrs.h> |
| 27 | #include <asm/sn/sn_private.h> |
| 28 | #include <asm/sn/sn0/ip27.h> |
| 29 | #include <asm/sn/sn0/hub.h> |
| 30 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 31 | #define TICK_SIZE (tick_nsec / 1000) |
| 32 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 33 | /* Includes for ioc3_init(). */ |
| 34 | #include <asm/sn/types.h> |
| 35 | #include <asm/sn/sn0/addrs.h> |
| 36 | #include <asm/sn/sn0/hubni.h> |
| 37 | #include <asm/sn/sn0/hubio.h> |
| 38 | #include <asm/pci/bridge.h> |
| 39 | |
Thomas Gleixner | 301218d | 2011-03-23 21:09:12 +0000 | [diff] [blame] | 40 | static void enable_rt_irq(struct irq_data *d) |
Ralf Baechle | 3c00944 | 2006-06-16 17:10:49 +0200 | [diff] [blame] | 41 | { |
| 42 | } |
| 43 | |
Thomas Gleixner | 301218d | 2011-03-23 21:09:12 +0000 | [diff] [blame] | 44 | static void disable_rt_irq(struct irq_data *d) |
Ralf Baechle | 3c00944 | 2006-06-16 17:10:49 +0200 | [diff] [blame] | 45 | { |
| 46 | } |
| 47 | |
Ralf Baechle | 94dee17 | 2006-07-02 14:41:42 +0100 | [diff] [blame] | 48 | static struct irq_chip rt_irq_type = { |
Atsushi Nemoto | 70d21cd | 2007-01-15 00:07:25 +0900 | [diff] [blame] | 49 | .name = "SN HUB RT timer", |
Thomas Gleixner | 301218d | 2011-03-23 21:09:12 +0000 | [diff] [blame] | 50 | .irq_mask = disable_rt_irq, |
| 51 | .irq_unmask = enable_rt_irq, |
Ralf Baechle | 3c00944 | 2006-06-16 17:10:49 +0200 | [diff] [blame] | 52 | }; |
| 53 | |
Ralf Baechle | 06d428d | 2007-10-22 10:34:13 +0100 | [diff] [blame] | 54 | static int rt_next_event(unsigned long delta, struct clock_event_device *evt) |
| 55 | { |
| 56 | unsigned int cpu = smp_processor_id(); |
Ralf Baechle | c892529 | 2007-11-01 12:20:51 +0000 | [diff] [blame] | 57 | int slice = cputoslice(cpu); |
Ralf Baechle | 06d428d | 2007-10-22 10:34:13 +0100 | [diff] [blame] | 58 | unsigned long cnt; |
| 59 | |
| 60 | cnt = LOCAL_HUB_L(PI_RT_COUNT); |
| 61 | cnt += delta; |
Ralf Baechle | 725d7b36 | 2007-10-28 23:02:37 +0000 | [diff] [blame] | 62 | LOCAL_HUB_S(PI_RT_COMPARE_A + PI_COUNT_OFFSET * slice, cnt); |
Ralf Baechle | 06d428d | 2007-10-22 10:34:13 +0100 | [diff] [blame] | 63 | |
| 64 | return LOCAL_HUB_L(PI_RT_COUNT) >= cnt ? -ETIME : 0; |
| 65 | } |
| 66 | |
Ralf Baechle | 9fcb705 | 2013-04-10 22:18:55 +0200 | [diff] [blame] | 67 | unsigned int rt_timer_irq; |
Ralf Baechle | e887b24 | 2007-10-18 13:34:12 +0100 | [diff] [blame] | 68 | |
Thomas Bogendoerfer | b32bb80 | 2008-04-08 23:43:57 +0200 | [diff] [blame] | 69 | static DEFINE_PER_CPU(struct clock_event_device, hub_rt_clockevent); |
| 70 | static DEFINE_PER_CPU(char [11], hub_rt_name); |
| 71 | |
Ralf Baechle | 06d428d | 2007-10-22 10:34:13 +0100 | [diff] [blame] | 72 | static irqreturn_t hub_rt_counter_handler(int irq, void *dev_id) |
Ralf Baechle | e887b24 | 2007-10-18 13:34:12 +0100 | [diff] [blame] | 73 | { |
Ralf Baechle | e887b24 | 2007-10-18 13:34:12 +0100 | [diff] [blame] | 74 | unsigned int cpu = smp_processor_id(); |
Thomas Bogendoerfer | b32bb80 | 2008-04-08 23:43:57 +0200 | [diff] [blame] | 75 | struct clock_event_device *cd = &per_cpu(hub_rt_clockevent, cpu); |
Ralf Baechle | 725d7b36 | 2007-10-28 23:02:37 +0000 | [diff] [blame] | 76 | int slice = cputoslice(cpu); |
Ralf Baechle | e887b24 | 2007-10-18 13:34:12 +0100 | [diff] [blame] | 77 | |
Ralf Baechle | 725d7b36 | 2007-10-28 23:02:37 +0000 | [diff] [blame] | 78 | /* |
| 79 | * Ack |
| 80 | */ |
Ralf Baechle | c892529 | 2007-11-01 12:20:51 +0000 | [diff] [blame] | 81 | LOCAL_HUB_S(PI_RT_PEND_A + PI_COUNT_OFFSET * slice, 0); |
Ralf Baechle | e887b24 | 2007-10-18 13:34:12 +0100 | [diff] [blame] | 82 | cd->event_handler(cd); |
| 83 | |
| 84 | return IRQ_HANDLED; |
| 85 | } |
| 86 | |
Ralf Baechle | 06d428d | 2007-10-22 10:34:13 +0100 | [diff] [blame] | 87 | struct irqaction hub_rt_irqaction = { |
| 88 | .handler = hub_rt_counter_handler, |
Yong Zhang | 8b5690f | 2011-11-22 14:38:03 +0000 | [diff] [blame] | 89 | .flags = IRQF_PERCPU | IRQF_TIMER, |
Ralf Baechle | 06d428d | 2007-10-22 10:34:13 +0100 | [diff] [blame] | 90 | .name = "hub-rt", |
Ralf Baechle | 3c00944 | 2006-06-16 17:10:49 +0200 | [diff] [blame] | 91 | }; |
| 92 | |
Ralf Baechle | e887b24 | 2007-10-18 13:34:12 +0100 | [diff] [blame] | 93 | /* |
| 94 | * This is a hack; we really need to figure these values out dynamically |
| 95 | * |
| 96 | * Since 800 ns works very well with various HUB frequencies, such as |
| 97 | * 360, 380, 390 and 400 MHZ, we use 800 ns rtc cycle time. |
| 98 | * |
| 99 | * Ralf: which clock rate is used to feed the counter? |
| 100 | */ |
| 101 | #define NSEC_PER_CYCLE 800 |
| 102 | #define CYCLES_PER_SEC (NSEC_PER_SEC / NSEC_PER_CYCLE) |
Ralf Baechle | 3c00944 | 2006-06-16 17:10:49 +0200 | [diff] [blame] | 103 | |
Paul Gortmaker | 078a55f | 2013-06-18 13:38:59 +0000 | [diff] [blame] | 104 | void hub_rt_clock_event_init(void) |
Ralf Baechle | e887b24 | 2007-10-18 13:34:12 +0100 | [diff] [blame] | 105 | { |
Ralf Baechle | e887b24 | 2007-10-18 13:34:12 +0100 | [diff] [blame] | 106 | unsigned int cpu = smp_processor_id(); |
Ralf Baechle | 06d428d | 2007-10-22 10:34:13 +0100 | [diff] [blame] | 107 | struct clock_event_device *cd = &per_cpu(hub_rt_clockevent, cpu); |
| 108 | unsigned char *name = per_cpu(hub_rt_name, cpu); |
| 109 | int irq = rt_timer_irq; |
Ralf Baechle | e887b24 | 2007-10-18 13:34:12 +0100 | [diff] [blame] | 110 | |
Ralf Baechle | 06d428d | 2007-10-22 10:34:13 +0100 | [diff] [blame] | 111 | sprintf(name, "hub-rt %d", cpu); |
Thomas Bogendoerfer | b32bb80 | 2008-04-08 23:43:57 +0200 | [diff] [blame] | 112 | cd->name = name; |
| 113 | cd->features = CLOCK_EVT_FEAT_ONESHOT; |
Ralf Baechle | 06d428d | 2007-10-22 10:34:13 +0100 | [diff] [blame] | 114 | clockevent_set_clock(cd, CYCLES_PER_SEC); |
Ralf Baechle | 7034228 | 2013-01-22 12:59:30 +0100 | [diff] [blame] | 115 | cd->max_delta_ns = clockevent_delta2ns(0xfffffffffffff, cd); |
| 116 | cd->min_delta_ns = clockevent_delta2ns(0x300, cd); |
Thomas Bogendoerfer | b32bb80 | 2008-04-08 23:43:57 +0200 | [diff] [blame] | 117 | cd->rating = 200; |
| 118 | cd->irq = irq; |
Rusty Russell | 320ab2b | 2008-12-13 21:20:26 +1030 | [diff] [blame] | 119 | cd->cpumask = cpumask_of(cpu); |
Thomas Bogendoerfer | b32bb80 | 2008-04-08 23:43:57 +0200 | [diff] [blame] | 120 | cd->set_next_event = rt_next_event; |
Ralf Baechle | e887b24 | 2007-10-18 13:34:12 +0100 | [diff] [blame] | 121 | clockevents_register_device(cd); |
Ralf Baechle | 06d428d | 2007-10-22 10:34:13 +0100 | [diff] [blame] | 122 | } |
| 123 | |
| 124 | static void __init hub_rt_clock_event_global_init(void) |
| 125 | { |
Roel Kluin | d0e7ba0 | 2008-04-16 17:09:58 +0200 | [diff] [blame] | 126 | int irq; |
Ralf Baechle | 06d428d | 2007-10-22 10:34:13 +0100 | [diff] [blame] | 127 | |
| 128 | do { |
| 129 | smp_wmb(); |
| 130 | irq = rt_timer_irq; |
| 131 | if (irq) |
| 132 | break; |
| 133 | |
| 134 | irq = allocate_irqno(); |
| 135 | if (irq < 0) |
| 136 | panic("Allocation of irq number for timer failed"); |
| 137 | } while (xchg(&rt_timer_irq, irq)); |
Ralf Baechle | e887b24 | 2007-10-18 13:34:12 +0100 | [diff] [blame] | 138 | |
Thomas Gleixner | e4ec798 | 2011-03-27 15:19:28 +0200 | [diff] [blame] | 139 | irq_set_chip_and_handler(irq, &rt_irq_type, handle_percpu_irq); |
Ralf Baechle | 06d428d | 2007-10-22 10:34:13 +0100 | [diff] [blame] | 140 | setup_irq(irq, &hub_rt_irqaction); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 141 | } |
| 142 | |
Magnus Damm | 8e19608 | 2009-04-21 12:24:00 -0700 | [diff] [blame] | 143 | static cycle_t hub_rt_read(struct clocksource *cs) |
Atsushi Nemoto | 16b7b2a | 2006-10-24 00:21:27 +0900 | [diff] [blame] | 144 | { |
| 145 | return REMOTE_HUB_L(cputonasid(0), PI_RT_COUNT); |
| 146 | } |
| 147 | |
Ralf Baechle | 06d428d | 2007-10-22 10:34:13 +0100 | [diff] [blame] | 148 | struct clocksource hub_rt_clocksource = { |
Ralf Baechle | e887b24 | 2007-10-18 13:34:12 +0100 | [diff] [blame] | 149 | .name = "HUB-RT", |
Ralf Baechle | 7034228 | 2013-01-22 12:59:30 +0100 | [diff] [blame] | 150 | .rating = 200, |
Ralf Baechle | 87b2335 | 2007-10-11 23:46:10 +0100 | [diff] [blame] | 151 | .read = hub_rt_read, |
| 152 | .mask = CLOCKSOURCE_MASK(52), |
Ralf Baechle | 87b2335 | 2007-10-11 23:46:10 +0100 | [diff] [blame] | 153 | .flags = CLOCK_SOURCE_IS_CONTINUOUS, |
| 154 | }; |
| 155 | |
Deng-Cheng Zhu | c41cef3 | 2015-03-07 10:30:29 -0800 | [diff] [blame] | 156 | static u64 notrace hub_rt_read_sched_clock(void) |
| 157 | { |
| 158 | return REMOTE_HUB_L(cputonasid(0), PI_RT_COUNT); |
| 159 | } |
| 160 | |
Ralf Baechle | 06d428d | 2007-10-22 10:34:13 +0100 | [diff] [blame] | 161 | static void __init hub_rt_clocksource_init(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 162 | { |
Ralf Baechle | 06d428d | 2007-10-22 10:34:13 +0100 | [diff] [blame] | 163 | struct clocksource *cs = &hub_rt_clocksource; |
| 164 | |
John Stultz | 75c4fd8 | 2010-04-26 20:23:11 -0700 | [diff] [blame] | 165 | clocksource_register_hz(cs, CYCLES_PER_SEC); |
Deng-Cheng Zhu | c41cef3 | 2015-03-07 10:30:29 -0800 | [diff] [blame] | 166 | |
| 167 | sched_clock_register(hub_rt_read_sched_clock, 52, CYCLES_PER_SEC); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 168 | } |
| 169 | |
Ralf Baechle | e887b24 | 2007-10-18 13:34:12 +0100 | [diff] [blame] | 170 | void __init plat_time_init(void) |
| 171 | { |
Ralf Baechle | 06d428d | 2007-10-22 10:34:13 +0100 | [diff] [blame] | 172 | hub_rt_clocksource_init(); |
| 173 | hub_rt_clock_event_global_init(); |
Thomas Bogendoerfer | b32bb80 | 2008-04-08 23:43:57 +0200 | [diff] [blame] | 174 | hub_rt_clock_event_init(); |
Ralf Baechle | e887b24 | 2007-10-18 13:34:12 +0100 | [diff] [blame] | 175 | } |
| 176 | |
Paul Gortmaker | 078a55f | 2013-06-18 13:38:59 +0000 | [diff] [blame] | 177 | void cpu_time_init(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 178 | { |
| 179 | lboard_t *board; |
| 180 | klcpu_t *cpu; |
| 181 | int cpuid; |
| 182 | |
| 183 | /* Don't use ARCS. ARCS is fragile. Klconfig is simple and sane. */ |
| 184 | board = find_lboard(KL_CONFIG_INFO(get_nasid()), KLTYPE_IP27); |
| 185 | if (!board) |
| 186 | panic("Can't find board info for myself."); |
| 187 | |
| 188 | cpuid = LOCAL_HUB_L(PI_CPU_NUM) ? IP27_CPU0_INDEX : IP27_CPU1_INDEX; |
| 189 | cpu = (klcpu_t *) KLCF_COMP(board, cpuid); |
| 190 | if (!cpu) |
| 191 | panic("No information about myself?"); |
| 192 | |
| 193 | printk("CPU %d clock is %dMHz.\n", smp_processor_id(), cpu->cpu_speed); |
| 194 | |
| 195 | set_c0_status(SRB_TIMOCLK); |
| 196 | } |
| 197 | |
Paul Gortmaker | 078a55f | 2013-06-18 13:38:59 +0000 | [diff] [blame] | 198 | void hub_rtc_init(cnodeid_t cnode) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 199 | { |
Thomas Bogendoerfer | 3ec066c | 2008-10-14 17:17:28 +0200 | [diff] [blame] | 200 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 201 | /* |
| 202 | * We only need to initialize the current node. |
| 203 | * If this is not the current node then it is a cpuless |
| 204 | * node and timeouts will not happen there. |
| 205 | */ |
| 206 | if (get_compact_nodeid() == cnode) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 207 | LOCAL_HUB_S(PI_RT_EN_A, 1); |
| 208 | LOCAL_HUB_S(PI_RT_EN_B, 1); |
| 209 | LOCAL_HUB_S(PI_PROF_EN_A, 0); |
| 210 | LOCAL_HUB_S(PI_PROF_EN_B, 0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 211 | LOCAL_HUB_S(PI_RT_COUNT, 0); |
| 212 | LOCAL_HUB_S(PI_RT_PEND_A, 0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 213 | LOCAL_HUB_S(PI_RT_PEND_B, 0); |
| 214 | } |
| 215 | } |
Thomas Bogendoerfer | 3ec066c | 2008-10-14 17:17:28 +0200 | [diff] [blame] | 216 | |
| 217 | static int __init sgi_ip27_rtc_devinit(void) |
| 218 | { |
| 219 | struct resource res; |
| 220 | |
| 221 | memset(&res, 0, sizeof(res)); |
| 222 | res.start = XPHYSADDR(KL_CONFIG_CH_CONS_INFO(master_nasid)->memory_base + |
| 223 | IOC3_BYTEBUS_DEV0); |
| 224 | res.end = res.start + 32767; |
| 225 | res.flags = IORESOURCE_MEM; |
| 226 | |
| 227 | return IS_ERR(platform_device_register_simple("rtc-m48t35", -1, |
| 228 | &res, 1)); |
| 229 | } |
| 230 | |
| 231 | /* |
| 232 | * kludge make this a device_initcall after ioc3 resource conflicts |
| 233 | * are resolved |
| 234 | */ |
| 235 | late_initcall(sgi_ip27_rtc_devinit); |