Git Repo - u-boot.git/blame_incremental - drivers/timer/timer-uclass.c

... / ...

Commit	Line	Data
	1	// SPDX-License-Identifier: GPL-2.0+
	2	/*
	3	* Copyright (C) 2015 Thomas Chou <[email protected]>
	4	*/
	5
	6	#include <common.h>
	7	#include <clk.h>
	8	#include <cpu.h>
	9	#include <dm.h>
	10	#include <dm/lists.h>
	11	#include <dm/device_compat.h>
	12	#include <dm/device-internal.h>
	13	#include <dm/root.h>
	14	#include <errno.h>
	15	#include <init.h>
	16	#include <timer.h>
	17	#include <linux/err.h>
	18
	19	DECLARE_GLOBAL_DATA_PTR;
	20
	21	/*
	22	* Implement a timer uclass to work with lib/time.c. The timer is usually
	23	* a 32/64 bits free-running up counter. The get_rate() method is used to get
	24	* the input clock frequency of the timer. The get_count() method is used
	25	* to get the current 64 bits count value. If the hardware is counting down,
	26	* the value should be inversed inside the method. There may be no real
	27	* tick, and no timer interrupt.
	28	*/
	29
	30	int notrace timer_get_count(struct udevice dev, u64 count)
	31	{
	32	const struct timer_ops *ops = device_get_ops(dev);
	33
	34	if (!ops->get_count)
	35	return -ENOSYS;
	36
	37	*count = ops->get_count(dev);
	38	return 0;
	39	}
	40
	41	unsigned long notrace timer_get_rate(struct udevice *dev)
	42	{
	43	struct timer_dev_priv *uc_priv = dev->uclass_priv;
	44
	45	return uc_priv->clock_rate;
	46	}
	47
	48	static int timer_pre_probe(struct udevice *dev)
	49	{
	50	#if !CONFIG_IS_ENABLED(OF_PLATDATA)
	51	struct timer_dev_priv *uc_priv = dev_get_uclass_priv(dev);
	52	struct clk timer_clk;
	53	int err;
	54	ulong ret;
	55
	56	/* It is possible that a timer device has a null ofnode */
	57	if (!dev_of_valid(dev))
	58	return 0;
	59
	60	err = clk_get_by_index(dev, 0, &timer_clk);
	61	if (!err) {
	62	ret = clk_get_rate(&timer_clk);
	63	if (IS_ERR_VALUE(ret))
	64	return ret;
	65	uc_priv->clock_rate = ret;
	66	} else {
	67	uc_priv->clock_rate =
	68	dev_read_u32_default(dev, "clock-frequency", 0);
	69	}
	70	#endif
	71
	72	return 0;
	73	}
	74
	75	static int timer_post_probe(struct udevice *dev)
	76	{
	77	struct timer_dev_priv *uc_priv = dev_get_uclass_priv(dev);
	78
	79	if (!uc_priv->clock_rate)
	80	return -EINVAL;
	81
	82	return 0;
	83	}
	84
	85	/*
	86	* TODO: should be CONFIG_IS_ENABLED(CPU), but the SPL config has _SUPPORT on
	87	* the end...
	88	*/
	89	#if defined(CONFIG_CPU) \|\| defined(CONFIG_SPL_CPU_SUPPORT)
	90	int timer_timebase_fallback(struct udevice *dev)
	91	{
	92	struct udevice *cpu;
	93	struct cpu_platdata *cpu_plat;
	94	struct timer_dev_priv *uc_priv = dev_get_uclass_priv(dev);
	95
	96	/* Did we get our clock rate from the device tree? */
	97	if (uc_priv->clock_rate)
	98	return 0;
	99
	100	/* Fall back to timebase-frequency */
	101	dev_dbg(dev, "missing clocks or clock-frequency property; falling back on timebase-frequency\n");
	102	cpu = cpu_get_current_dev();
	103	if (!cpu)
	104	return -ENODEV;
	105
	106	cpu_plat = dev_get_parent_platdata(cpu);
	107	if (!cpu_plat)
	108	return -ENODEV;
	109
	110	uc_priv->clock_rate = cpu_plat->timebase_freq;
	111	return 0;
	112	}
	113	#endif
	114
	115	u64 timer_conv_64(u32 count)
	116	{
	117	/* increment tbh if tbl has rolled over */
	118	if (count < gd->timebase_l)
	119	gd->timebase_h++;
	120	gd->timebase_l = count;
	121	return ((u64)gd->timebase_h << 32) \| gd->timebase_l;
	122	}
	123
	124	int notrace dm_timer_init(void)
	125	{
	126	struct udevice *dev = NULL;
	127	__maybe_unused ofnode node;
	128	int ret;
	129
	130	if (gd->timer)
	131	return 0;
	132
	133	/*
	134	* Directly access gd->dm_root to suppress error messages, if the
	135	* virtual root driver does not yet exist.
	136	*/
	137	if (gd->dm_root == NULL)
	138	return -EAGAIN;
	139
	140	#if !CONFIG_IS_ENABLED(OF_PLATDATA)
	141	/* Check for a chosen timer to be used for tick */
	142	node = ofnode_get_chosen_node("tick-timer");
	143
	144	if (ofnode_valid(node) &&
	145	uclass_get_device_by_ofnode(UCLASS_TIMER, node, &dev)) {
	146	/*
	147	* If the timer is not marked to be bound before
	148	* relocation, bind it anyway.
	149	*/
	150	if (!lists_bind_fdt(dm_root(), node, &dev, false)) {
	151	ret = device_probe(dev);
	152	if (ret)
	153	return ret;
	154	}
	155	}
	156	#endif
	157
	158	if (!dev) {
	159	/* Fall back to the first available timer */
	160	ret = uclass_first_device_err(UCLASS_TIMER, &dev);
	161	if (ret)
	162	return ret;
	163	}
	164
	165	if (dev) {
	166	gd->timer = dev;
	167	return 0;
	168	}
	169
	170	return -ENODEV;
	171	}
	172
	173	UCLASS_DRIVER(timer) = {
	174	.id = UCLASS_TIMER,
	175	.name = "timer",
	176	.pre_probe = timer_pre_probe,
	177	.flags = DM_UC_FLAG_SEQ_ALIAS,
	178	.post_probe = timer_post_probe,
	179	.per_device_auto_alloc_size = sizeof(struct timer_dev_priv),
	180	};