1 /* 2 * Integrator/AP timer driver 3 * Copyright (C) 2000-2003 Deep Blue Solutions Ltd 4 * Copyright (c) 2014, Linaro Limited 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 19 */ 20 21 #include <linux/clk.h> 22 #include <linux/clocksource.h> 23 #include <linux/of_irq.h> 24 #include <linux/of_address.h> 25 #include <linux/of_platform.h> 26 #include <linux/clockchips.h> 27 #include <linux/interrupt.h> 28 #include <linux/sched_clock.h> 29 30 #include "timer-sp.h" 31 32 static void __iomem * sched_clk_base; 33 34 static u64 notrace integrator_read_sched_clock(void) 35 { 36 return -readl(sched_clk_base + TIMER_VALUE); 37 } 38 39 static int __init integrator_clocksource_init(unsigned long inrate, 40 void __iomem *base) 41 { 42 u32 ctrl = TIMER_CTRL_ENABLE | TIMER_CTRL_PERIODIC; 43 unsigned long rate = inrate; 44 int ret; 45 46 if (rate >= 1500000) { 47 rate /= 16; 48 ctrl |= TIMER_CTRL_DIV16; 49 } 50 51 writel(0xffff, base + TIMER_LOAD); 52 writel(ctrl, base + TIMER_CTRL); 53 54 ret = clocksource_mmio_init(base + TIMER_VALUE, "timer2", 55 rate, 200, 16, clocksource_mmio_readl_down); 56 if (ret) 57 return ret; 58 59 sched_clk_base = base; 60 sched_clock_register(integrator_read_sched_clock, 16, rate); 61 62 return 0; 63 } 64 65 static unsigned long timer_reload; 66 static void __iomem * clkevt_base; 67 68 /* 69 * IRQ handler for the timer 70 */ 71 static irqreturn_t integrator_timer_interrupt(int irq, void *dev_id) 72 { 73 struct clock_event_device *evt = dev_id; 74 75 /* clear the interrupt */ 76 writel(1, clkevt_base + TIMER_INTCLR); 77 78 evt->event_handler(evt); 79 80 return IRQ_HANDLED; 81 } 82 83 static int clkevt_shutdown(struct clock_event_device *evt) 84 { 85 u32 ctrl = readl(clkevt_base + TIMER_CTRL) & ~TIMER_CTRL_ENABLE; 86 87 /* Disable timer */ 88 writel(ctrl, clkevt_base + TIMER_CTRL); 89 return 0; 90 } 91 92 static int clkevt_set_oneshot(struct clock_event_device *evt) 93 { 94 u32 ctrl = readl(clkevt_base + TIMER_CTRL) & 95 ~(TIMER_CTRL_ENABLE | TIMER_CTRL_PERIODIC); 96 97 /* Leave the timer disabled, .set_next_event will enable it */ 98 writel(ctrl, clkevt_base + TIMER_CTRL); 99 return 0; 100 } 101 102 static int clkevt_set_periodic(struct clock_event_device *evt) 103 { 104 u32 ctrl = readl(clkevt_base + TIMER_CTRL) & ~TIMER_CTRL_ENABLE; 105 106 /* Disable timer */ 107 writel(ctrl, clkevt_base + TIMER_CTRL); 108 109 /* Enable the timer and start the periodic tick */ 110 writel(timer_reload, clkevt_base + TIMER_LOAD); 111 ctrl |= TIMER_CTRL_PERIODIC | TIMER_CTRL_ENABLE; 112 writel(ctrl, clkevt_base + TIMER_CTRL); 113 return 0; 114 } 115 116 static int clkevt_set_next_event(unsigned long next, struct clock_event_device *evt) 117 { 118 unsigned long ctrl = readl(clkevt_base + TIMER_CTRL); 119 120 writel(ctrl & ~TIMER_CTRL_ENABLE, clkevt_base + TIMER_CTRL); 121 writel(next, clkevt_base + TIMER_LOAD); 122 writel(ctrl | TIMER_CTRL_ENABLE, clkevt_base + TIMER_CTRL); 123 124 return 0; 125 } 126 127 static struct clock_event_device integrator_clockevent = { 128 .name = "timer1", 129 .features = CLOCK_EVT_FEAT_PERIODIC | 130 CLOCK_EVT_FEAT_ONESHOT, 131 .set_state_shutdown = clkevt_shutdown, 132 .set_state_periodic = clkevt_set_periodic, 133 .set_state_oneshot = clkevt_set_oneshot, 134 .tick_resume = clkevt_shutdown, 135 .set_next_event = clkevt_set_next_event, 136 .rating = 300, 137 }; 138 139 static struct irqaction integrator_timer_irq = { 140 .name = "timer", 141 .flags = IRQF_TIMER | IRQF_IRQPOLL, 142 .handler = integrator_timer_interrupt, 143 .dev_id = &integrator_clockevent, 144 }; 145 146 static int integrator_clockevent_init(unsigned long inrate, 147 void __iomem *base, int irq) 148 { 149 unsigned long rate = inrate; 150 unsigned int ctrl = 0; 151 int ret; 152 153 clkevt_base = base; 154 /* Calculate and program a divisor */ 155 if (rate > 0x100000 * HZ) { 156 rate /= 256; 157 ctrl |= TIMER_CTRL_DIV256; 158 } else if (rate > 0x10000 * HZ) { 159 rate /= 16; 160 ctrl |= TIMER_CTRL_DIV16; 161 } 162 timer_reload = rate / HZ; 163 writel(ctrl, clkevt_base + TIMER_CTRL); 164 165 ret = setup_irq(irq, &integrator_timer_irq); 166 if (ret) 167 return ret; 168 169 clockevents_config_and_register(&integrator_clockevent, 170 rate, 171 1, 172 0xffffU); 173 return 0; 174 } 175 176 static int __init integrator_ap_timer_init_of(struct device_node *node) 177 { 178 const char *path; 179 void __iomem *base; 180 int err; 181 int irq; 182 struct clk *clk; 183 unsigned long rate; 184 struct device_node *alias_node; 185 186 base = of_io_request_and_map(node, 0, "integrator-timer"); 187 if (IS_ERR(base)) 188 return PTR_ERR(base); 189 190 clk = of_clk_get(node, 0); 191 if (IS_ERR(clk)) { 192 pr_err("No clock for %pOFn\n", node); 193 return PTR_ERR(clk); 194 } 195 clk_prepare_enable(clk); 196 rate = clk_get_rate(clk); 197 writel(0, base + TIMER_CTRL); 198 199 err = of_property_read_string(of_aliases, 200 "arm,timer-primary", &path); 201 if (err) { 202 pr_warn("Failed to read property\n"); 203 return err; 204 } 205 206 alias_node = of_find_node_by_path(path); 207 208 /* 209 * The pointer is used as an identifier not as a pointer, we 210 * can drop the refcount on the of__node immediately after 211 * getting it. 212 */ 213 of_node_put(alias_node); 214 215 if (node == alias_node) 216 /* The primary timer lacks IRQ, use as clocksource */ 217 return integrator_clocksource_init(rate, base); 218 219 err = of_property_read_string(of_aliases, 220 "arm,timer-secondary", &path); 221 if (err) { 222 pr_warn("Failed to read property\n"); 223 return err; 224 } 225 226 alias_node = of_find_node_by_path(path); 227 228 of_node_put(alias_node); 229 230 if (node == alias_node) { 231 /* The secondary timer will drive the clock event */ 232 irq = irq_of_parse_and_map(node, 0); 233 return integrator_clockevent_init(rate, base, irq); 234 } 235 236 pr_info("Timer @%p unused\n", base); 237 clk_disable_unprepare(clk); 238 239 return 0; 240 } 241 242 TIMER_OF_DECLARE(integrator_ap_timer, "arm,integrator-timer", 243 integrator_ap_timer_init_of); 244