xref: /freebsd/sys/arm/ti/am335x/am335x_dmtimer.c (revision 42249ef2)
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3  *
4  * Copyright (c) 2012 Damjan Marion <dmarion@Freebsd.org>
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26  * SUCH DAMAGE.
27  */
28 
29 #include <sys/cdefs.h>
30 __FBSDID("$FreeBSD$");
31 
32 #include <sys/param.h>
33 #include <sys/systm.h>
34 #include <sys/bus.h>
35 #include <sys/kernel.h>
36 #include <sys/module.h>
37 #include <sys/malloc.h>
38 #include <sys/rman.h>
39 #include <sys/timeet.h>
40 #include <sys/timetc.h>
41 #include <machine/bus.h>
42 
43 #include <machine/machdep.h> /* For arm_set_delay */
44 
45 #include <dev/ofw/openfirm.h>
46 #include <dev/ofw/ofw_bus.h>
47 #include <dev/ofw/ofw_bus_subr.h>
48 
49 #include <arm/ti/ti_prcm.h>
50 #include <arm/ti/ti_hwmods.h>
51 
52 #include "am335x_dmtreg.h"
53 
54 struct am335x_dmtimer_softc {
55 	device_t		dev;
56 	int			tmr_mem_rid;
57 	struct resource *	tmr_mem_res;
58 	int			tmr_irq_rid;
59 	struct resource *	tmr_irq_res;
60 	void			*tmr_irq_handler;
61 	uint32_t		sysclk_freq;
62 	uint32_t		tclr;		/* Cached TCLR register. */
63 	union {
64 		struct timecounter tc;
65 		struct eventtimer et;
66 	} func;
67 	int			tmr_num;	/* Hardware unit number. */
68 	char			tmr_name[12];	/* "DMTimerN", N = tmr_num */
69 };
70 
71 static struct am335x_dmtimer_softc *am335x_dmtimer_et_sc = NULL;
72 static struct am335x_dmtimer_softc *am335x_dmtimer_tc_sc = NULL;
73 
74 static void am335x_dmtimer_delay(int, void *);
75 
76 /*
77  * We use dmtimer2 for eventtimer and dmtimer3 for timecounter.
78  */
79 #define ET_TMR_NUM      2
80 #define TC_TMR_NUM      3
81 
82 /* List of compatible strings for FDT tree */
83 static struct ofw_compat_data compat_data[] = {
84 	{"ti,am335x-timer",     1},
85 	{"ti,am335x-timer-1ms", 1},
86 	{NULL,                  0},
87 };
88 
89 #define	DMTIMER_READ4(sc, reg)		bus_read_4((sc)->tmr_mem_res, (reg))
90 #define	DMTIMER_WRITE4(sc, reg, val)	bus_write_4((sc)->tmr_mem_res, (reg), (val))
91 
92 static int
93 am335x_dmtimer_et_start(struct eventtimer *et, sbintime_t first, sbintime_t period)
94 {
95 	struct am335x_dmtimer_softc *sc;
96 	uint32_t initial_count, reload_count;
97 
98 	sc = et->et_priv;
99 
100 	/*
101 	 * Stop the timer before changing it.  This routine will often be called
102 	 * while the timer is still running, to either lengthen or shorten the
103 	 * current event time.  We need to ensure the timer doesn't expire while
104 	 * we're working with it.
105 	 *
106 	 * Also clear any pending interrupt status, because it's at least
107 	 * theoretically possible that we're running in a primary interrupt
108 	 * context now, and a timer interrupt could be pending even before we
109 	 * stopped the timer.  The more likely case is that we're being called
110 	 * from the et_event_cb() routine dispatched from our own handler, but
111 	 * it's not clear to me that that's the only case possible.
112 	 */
113 	sc->tclr &= ~(DMT_TCLR_START | DMT_TCLR_AUTOLOAD);
114 	DMTIMER_WRITE4(sc, DMT_TCLR, sc->tclr);
115 	DMTIMER_WRITE4(sc, DMT_IRQSTATUS, DMT_IRQ_OVF);
116 
117 	if (period != 0) {
118 		reload_count = ((uint32_t)et->et_frequency * period) >> 32;
119 		sc->tclr |= DMT_TCLR_AUTOLOAD;
120 	} else {
121 		reload_count = 0;
122 	}
123 
124 	if (first != 0)
125 		initial_count = ((uint32_t)et->et_frequency * first) >> 32;
126 	else
127 		initial_count = reload_count;
128 
129 	/*
130 	 * Set auto-reload and current-count values.  This timer hardware counts
131 	 * up from the initial/reload value and interrupts on the zero rollover.
132 	 */
133 	DMTIMER_WRITE4(sc, DMT_TLDR, 0xFFFFFFFF - reload_count);
134 	DMTIMER_WRITE4(sc, DMT_TCRR, 0xFFFFFFFF - initial_count);
135 
136 	/* Enable overflow interrupt, and start the timer. */
137 	DMTIMER_WRITE4(sc, DMT_IRQENABLE_SET, DMT_IRQ_OVF);
138 	sc->tclr |= DMT_TCLR_START;
139 	DMTIMER_WRITE4(sc, DMT_TCLR, sc->tclr);
140 
141 	return (0);
142 }
143 
144 static int
145 am335x_dmtimer_et_stop(struct eventtimer *et)
146 {
147 	struct am335x_dmtimer_softc *sc;
148 
149 	sc = et->et_priv;
150 
151 	/* Stop timer, disable and clear interrupt. */
152 	sc->tclr &= ~(DMT_TCLR_START | DMT_TCLR_AUTOLOAD);
153 	DMTIMER_WRITE4(sc, DMT_TCLR, sc->tclr);
154 	DMTIMER_WRITE4(sc, DMT_IRQENABLE_CLR, DMT_IRQ_OVF);
155 	DMTIMER_WRITE4(sc, DMT_IRQSTATUS, DMT_IRQ_OVF);
156 	return (0);
157 }
158 
159 static int
160 am335x_dmtimer_et_intr(void *arg)
161 {
162 	struct am335x_dmtimer_softc *sc;
163 
164 	sc = arg;
165 
166 	/* Ack the interrupt, and invoke the callback if it's still enabled. */
167 	DMTIMER_WRITE4(sc, DMT_IRQSTATUS, DMT_IRQ_OVF);
168 	if (sc->func.et.et_active)
169 		sc->func.et.et_event_cb(&sc->func.et, sc->func.et.et_arg);
170 
171 	return (FILTER_HANDLED);
172 }
173 
174 static int
175 am335x_dmtimer_et_init(struct am335x_dmtimer_softc *sc)
176 {
177 	KASSERT(am335x_dmtimer_et_sc == NULL, ("already have an eventtimer"));
178 
179 	/*
180 	 * Setup eventtimer interrupt handling.  Panic if anything goes wrong,
181 	 * because the system just isn't going to run without an eventtimer.
182 	 */
183 	sc->tmr_irq_res = bus_alloc_resource_any(sc->dev, SYS_RES_IRQ,
184 	    &sc->tmr_irq_rid, RF_ACTIVE);
185 	if (sc->tmr_irq_res == NULL)
186 		panic("am335x_dmtimer: could not allocate irq resources");
187 	if (bus_setup_intr(sc->dev, sc->tmr_irq_res, INTR_TYPE_CLK,
188 	    am335x_dmtimer_et_intr, NULL, sc, &sc->tmr_irq_handler) != 0)
189 		panic("am335x_dmtimer: count not setup irq handler");
190 
191 	sc->func.et.et_name = sc->tmr_name;
192 	sc->func.et.et_flags = ET_FLAGS_PERIODIC | ET_FLAGS_ONESHOT;
193 	sc->func.et.et_quality = 500;
194 	sc->func.et.et_frequency = sc->sysclk_freq;
195 	sc->func.et.et_min_period =
196 	    ((0x00000005LLU << 32) / sc->func.et.et_frequency);
197 	sc->func.et.et_max_period =
198 	    (0xfffffffeLLU << 32) / sc->func.et.et_frequency;
199 	sc->func.et.et_start = am335x_dmtimer_et_start;
200 	sc->func.et.et_stop = am335x_dmtimer_et_stop;
201 	sc->func.et.et_priv = sc;
202 
203 	am335x_dmtimer_et_sc = sc;
204 	et_register(&sc->func.et);
205 
206 	return (0);
207 }
208 
209 static unsigned
210 am335x_dmtimer_tc_get_timecount(struct timecounter *tc)
211 {
212 	struct am335x_dmtimer_softc *sc;
213 
214 	sc = tc->tc_priv;
215 
216 	return (DMTIMER_READ4(sc, DMT_TCRR));
217 }
218 
219 static int
220 am335x_dmtimer_tc_init(struct am335x_dmtimer_softc *sc)
221 {
222 	KASSERT(am335x_dmtimer_tc_sc == NULL, ("already have a timecounter"));
223 
224 	/* Set up timecounter, start it, register it. */
225 	DMTIMER_WRITE4(sc, DMT_TSICR, DMT_TSICR_RESET);
226 	while (DMTIMER_READ4(sc, DMT_TIOCP_CFG) & DMT_TIOCP_RESET)
227 		continue;
228 
229 	sc->tclr |= DMT_TCLR_START | DMT_TCLR_AUTOLOAD;
230 	DMTIMER_WRITE4(sc, DMT_TLDR, 0);
231 	DMTIMER_WRITE4(sc, DMT_TCRR, 0);
232 	DMTIMER_WRITE4(sc, DMT_TCLR, sc->tclr);
233 
234 	sc->func.tc.tc_name           = sc->tmr_name;
235 	sc->func.tc.tc_get_timecount  = am335x_dmtimer_tc_get_timecount;
236 	sc->func.tc.tc_counter_mask   = ~0u;
237 	sc->func.tc.tc_frequency      = sc->sysclk_freq;
238 	sc->func.tc.tc_quality        = 500;
239 	sc->func.tc.tc_priv           = sc;
240 
241 	am335x_dmtimer_tc_sc = sc;
242 	tc_init(&sc->func.tc);
243 
244 	arm_set_delay(am335x_dmtimer_delay, sc);
245 
246 	return (0);
247 }
248 
249 static int
250 am335x_dmtimer_probe(device_t dev)
251 {
252 	char strbuf[32];
253 	int tmr_num;
254 
255 	if (!ofw_bus_status_okay(dev))
256 		return (ENXIO);
257 
258 	if (ofw_bus_search_compatible(dev, compat_data)->ocd_data == 0)
259 		return (ENXIO);
260 
261 	/*
262 	 * Get the hardware unit number (the N from ti,hwmods="timerN").
263 	 * If this isn't the hardware unit we're going to use for either the
264 	 * eventtimer or the timecounter, no point in instantiating the device.
265 	 */
266 	tmr_num = ti_hwmods_get_unit(dev, "timer");
267 	if (tmr_num != ET_TMR_NUM && tmr_num != TC_TMR_NUM)
268 		return (ENXIO);
269 
270 	snprintf(strbuf, sizeof(strbuf), "AM335x DMTimer%d", tmr_num);
271 	device_set_desc_copy(dev, strbuf);
272 
273 	return(BUS_PROBE_DEFAULT);
274 }
275 
276 static int
277 am335x_dmtimer_attach(device_t dev)
278 {
279 	struct am335x_dmtimer_softc *sc;
280 	clk_ident_t timer_id;
281 	int err;
282 
283 	sc = device_get_softc(dev);
284 	sc->dev = dev;
285 
286 	/* Get the base clock frequency. */
287 	if ((err = ti_prcm_clk_get_source_freq(SYS_CLK, &sc->sysclk_freq)) != 0)
288 		return (err);
289 
290 	/* Enable clocks and power on the device. */
291 	if ((timer_id = ti_hwmods_get_clock(dev)) == INVALID_CLK_IDENT)
292 		return (ENXIO);
293 	if ((err = ti_prcm_clk_set_source(timer_id, SYSCLK_CLK)) != 0)
294 		return (err);
295 	if ((err = ti_prcm_clk_enable(timer_id)) != 0)
296 		return (err);
297 
298 	/* Request the memory resources. */
299 	sc->tmr_mem_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
300 	    &sc->tmr_mem_rid, RF_ACTIVE);
301 	if (sc->tmr_mem_res == NULL) {
302 		return (ENXIO);
303 	}
304 
305 	sc->tmr_num = ti_hwmods_get_unit(dev, "timer");
306 	snprintf(sc->tmr_name, sizeof(sc->tmr_name), "DMTimer%d", sc->tmr_num);
307 
308 	/*
309 	 * Go set up either a timecounter or eventtimer.  We wouldn't have
310 	 * attached if we weren't one or the other.
311 	 */
312 	if (sc->tmr_num == ET_TMR_NUM)
313 		am335x_dmtimer_et_init(sc);
314 	else if (sc->tmr_num == TC_TMR_NUM)
315 		am335x_dmtimer_tc_init(sc);
316 	else
317 		panic("am335x_dmtimer: bad timer number %d", sc->tmr_num);
318 
319 	return (0);
320 }
321 
322 static device_method_t am335x_dmtimer_methods[] = {
323 	DEVMETHOD(device_probe,		am335x_dmtimer_probe),
324 	DEVMETHOD(device_attach,	am335x_dmtimer_attach),
325 	{ 0, 0 }
326 };
327 
328 static driver_t am335x_dmtimer_driver = {
329 	"am335x_dmtimer",
330 	am335x_dmtimer_methods,
331 	sizeof(struct am335x_dmtimer_softc),
332 };
333 
334 static devclass_t am335x_dmtimer_devclass;
335 
336 DRIVER_MODULE(am335x_dmtimer, simplebus, am335x_dmtimer_driver, am335x_dmtimer_devclass, 0, 0);
337 MODULE_DEPEND(am335x_dmtimer, am335x_prcm, 1, 1, 1);
338 
339 static void
340 am335x_dmtimer_delay(int usec, void *arg)
341 {
342 	struct am335x_dmtimer_softc *sc = arg;
343 	int32_t counts;
344 	uint32_t first, last;
345 
346 	/* Get the number of times to count */
347 	counts = (usec + 1) * (sc->sysclk_freq / 1000000);
348 
349 	first = DMTIMER_READ4(sc, DMT_TCRR);
350 
351 	while (counts > 0) {
352 		last = DMTIMER_READ4(sc, DMT_TCRR);
353 		if (last > first) {
354 			counts -= (int32_t)(last - first);
355 		} else {
356 			counts -= (int32_t)((0xFFFFFFFF - first) + last);
357 		}
358 		first = last;
359 	}
360 }
361