1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * Copyright © 2014-2017 Broadcom
  4 */
  5
  6#define pr_fmt(fmt)	KBUILD_MODNAME ": " fmt
  7
  8#include <linux/clk.h>
  9#include <linux/device.h>
 10#include <linux/err.h>
 11#include <linux/init.h>
 12#include <linux/interrupt.h>
 13#include <linux/io.h>
 14#include <linux/irqreturn.h>
 15#include <linux/kernel.h>
 16#include <linux/module.h>
 17#include <linux/of.h>
 18#include <linux/platform_device.h>
 19#include <linux/pm.h>
 20#include <linux/pm_wakeup.h>
 21#include <linux/reboot.h>
 22#include <linux/rtc.h>
 23#include <linux/stat.h>
 24#include <linux/suspend.h>
 25
 26struct brcmstb_waketmr {
 27	struct rtc_device *rtc;
 28	struct device *dev;
 29	void __iomem *base;
 30	int irq;
 31	struct notifier_block reboot_notifier;
 32	struct clk *clk;
 33	u32 rate;
 34};
 35
 36#define BRCMSTB_WKTMR_EVENT		0x00
 37#define BRCMSTB_WKTMR_COUNTER		0x04
 38#define BRCMSTB_WKTMR_ALARM		0x08
 39#define BRCMSTB_WKTMR_PRESCALER		0x0C
 40#define BRCMSTB_WKTMR_PRESCALER_VAL	0x10
 41
 42#define BRCMSTB_WKTMR_DEFAULT_FREQ	27000000
 43
 44static inline void brcmstb_waketmr_clear_alarm(struct brcmstb_waketmr *timer)
 45{
 46	writel_relaxed(1, timer->base + BRCMSTB_WKTMR_EVENT);
 47	(void)readl_relaxed(timer->base + BRCMSTB_WKTMR_EVENT);
 48}
 49
 50static void brcmstb_waketmr_set_alarm(struct brcmstb_waketmr *timer,
 51				      unsigned int secs)
 52{
 53	brcmstb_waketmr_clear_alarm(timer);
 54
 55	/* Make sure we are actually counting in seconds */
 56	writel_relaxed(timer->rate, timer->base + BRCMSTB_WKTMR_PRESCALER);
 57
 58	writel_relaxed(secs + 1, timer->base + BRCMSTB_WKTMR_ALARM);
 59}
 60
 61static irqreturn_t brcmstb_waketmr_irq(int irq, void *data)
 62{
 63	struct brcmstb_waketmr *timer = data;
 64
 65	pm_wakeup_event(timer->dev, 0);
 66
 67	return IRQ_HANDLED;
 68}
 69
 70struct wktmr_time {
 71	u32 sec;
 72	u32 pre;
 73};
 74
 75static void wktmr_read(struct brcmstb_waketmr *timer,
 76		       struct wktmr_time *t)
 77{
 78	u32 tmp;
 79
 80	do {
 81		t->sec = readl_relaxed(timer->base + BRCMSTB_WKTMR_COUNTER);
 82		tmp = readl_relaxed(timer->base + BRCMSTB_WKTMR_PRESCALER_VAL);
 83	} while (tmp >= timer->rate);
 84
 85	t->pre = timer->rate - tmp;
 86}
 87
 88static int brcmstb_waketmr_prepare_suspend(struct brcmstb_waketmr *timer)
 89{
 90	struct device *dev = timer->dev;
 91	int ret = 0;
 92
 93	if (device_may_wakeup(dev)) {
 94		ret = enable_irq_wake(timer->irq);
 95		if (ret) {
 96			dev_err(dev, "failed to enable wake-up interrupt\n");
 97			return ret;
 98		}
 99	}
100
101	return ret;
102}
103
104/* If enabled as a wakeup-source, arm the timer when powering off */
105static int brcmstb_waketmr_reboot(struct notifier_block *nb,
106		unsigned long action, void *data)
107{
108	struct brcmstb_waketmr *timer;
109
110	timer = container_of(nb, struct brcmstb_waketmr, reboot_notifier);
111
112	/* Set timer for cold boot */
113	if (action == SYS_POWER_OFF)
114		brcmstb_waketmr_prepare_suspend(timer);
115
116	return NOTIFY_DONE;
117}
118
119static int brcmstb_waketmr_gettime(struct device *dev,
120				   struct rtc_time *tm)
121{
122	struct brcmstb_waketmr *timer = dev_get_drvdata(dev);
123	struct wktmr_time now;
124
125	wktmr_read(timer, &now);
126
127	rtc_time64_to_tm(now.sec, tm);
128
129	return 0;
130}
131
132static int brcmstb_waketmr_settime(struct device *dev,
133				   struct rtc_time *tm)
134{
135	struct brcmstb_waketmr *timer = dev_get_drvdata(dev);
136	time64_t sec;
137
138	sec = rtc_tm_to_time64(tm);
139
140	writel_relaxed(sec, timer->base + BRCMSTB_WKTMR_COUNTER);
141
142	return 0;
143}
144
145static int brcmstb_waketmr_getalarm(struct device *dev,
146				    struct rtc_wkalrm *alarm)
147{
148	struct brcmstb_waketmr *timer = dev_get_drvdata(dev);
149	time64_t sec;
150	u32 reg;
151
152	sec = readl_relaxed(timer->base + BRCMSTB_WKTMR_ALARM);
153	if (sec != 0) {
154		/* Alarm is enabled */
155		alarm->enabled = 1;
156		rtc_time64_to_tm(sec, &alarm->time);
157	}
158
159	reg = readl_relaxed(timer->base + BRCMSTB_WKTMR_EVENT);
160	alarm->pending = !!(reg & 1);
161
162	return 0;
163}
164
165static int brcmstb_waketmr_setalarm(struct device *dev,
166				     struct rtc_wkalrm *alarm)
167{
168	struct brcmstb_waketmr *timer = dev_get_drvdata(dev);
169	time64_t sec;
170
171	if (alarm->enabled)
172		sec = rtc_tm_to_time64(&alarm->time);
173	else
174		sec = 0;
175
176	brcmstb_waketmr_set_alarm(timer, sec);
177
178	return 0;
179}
180
181/*
182 * Does not do much but keep the RTC class happy. We always support
183 * alarms.
184 */
185static int brcmstb_waketmr_alarm_enable(struct device *dev,
186					unsigned int enabled)
187{
188	return 0;
189}
190
191static const struct rtc_class_ops brcmstb_waketmr_ops = {
192	.read_time	= brcmstb_waketmr_gettime,
193	.set_time	= brcmstb_waketmr_settime,
194	.read_alarm	= brcmstb_waketmr_getalarm,
195	.set_alarm	= brcmstb_waketmr_setalarm,
196	.alarm_irq_enable = brcmstb_waketmr_alarm_enable,
197};
198
199static int brcmstb_waketmr_probe(struct platform_device *pdev)
200{
201	struct device *dev = &pdev->dev;
202	struct brcmstb_waketmr *timer;
203	int ret;
204
205	timer = devm_kzalloc(dev, sizeof(*timer), GFP_KERNEL);
206	if (!timer)
207		return -ENOMEM;
208
209	platform_set_drvdata(pdev, timer);
210	timer->dev = dev;
211
212	timer->base = devm_platform_ioremap_resource(pdev, 0);
213	if (IS_ERR(timer->base))
214		return PTR_ERR(timer->base);
215
216	timer->rtc = devm_rtc_allocate_device(dev);
217	if (IS_ERR(timer->rtc))
218		return PTR_ERR(timer->rtc);
219
220	/*
221	 * Set wakeup capability before requesting wakeup interrupt, so we can
222	 * process boot-time "wakeups" (e.g., from S5 soft-off)
223	 */
224	device_set_wakeup_capable(dev, true);
225	device_wakeup_enable(dev);
226
227	timer->irq = platform_get_irq(pdev, 0);
228	if (timer->irq < 0)
229		return -ENODEV;
230
231	timer->clk = devm_clk_get(dev, NULL);
232	if (!IS_ERR(timer->clk)) {
233		ret = clk_prepare_enable(timer->clk);
234		if (ret)
235			return ret;
236		timer->rate = clk_get_rate(timer->clk);
237		if (!timer->rate)
238			timer->rate = BRCMSTB_WKTMR_DEFAULT_FREQ;
239	} else {
240		timer->rate = BRCMSTB_WKTMR_DEFAULT_FREQ;
241		timer->clk = NULL;
242	}
243
244	ret = devm_request_irq(dev, timer->irq, brcmstb_waketmr_irq, 0,
245			       "brcmstb-waketimer", timer);
246	if (ret < 0)
247		goto err_clk;
248
249	timer->reboot_notifier.notifier_call = brcmstb_waketmr_reboot;
250	register_reboot_notifier(&timer->reboot_notifier);
251
252	timer->rtc->ops = &brcmstb_waketmr_ops;
253	timer->rtc->range_max = U32_MAX;
254
255	ret = rtc_register_device(timer->rtc);
256	if (ret)
257		goto err_notifier;
258
259	dev_info(dev, "registered, with irq %d\n", timer->irq);
260
261	return 0;
262
263err_notifier:
264	unregister_reboot_notifier(&timer->reboot_notifier);
265
266err_clk:
267	if (timer->clk)
268		clk_disable_unprepare(timer->clk);
269
270	return ret;
271}
272
273static int brcmstb_waketmr_remove(struct platform_device *pdev)
274{
275	struct brcmstb_waketmr *timer = dev_get_drvdata(&pdev->dev);
276
277	unregister_reboot_notifier(&timer->reboot_notifier);
278	clk_disable_unprepare(timer->clk);
279
280	return 0;
281}
282
283#ifdef CONFIG_PM_SLEEP
284static int brcmstb_waketmr_suspend(struct device *dev)
285{
286	struct brcmstb_waketmr *timer = dev_get_drvdata(dev);
287
288	return brcmstb_waketmr_prepare_suspend(timer);
289}
290
291static int brcmstb_waketmr_resume(struct device *dev)
292{
293	struct brcmstb_waketmr *timer = dev_get_drvdata(dev);
294	int ret;
295
296	if (!device_may_wakeup(dev))
297		return 0;
298
299	ret = disable_irq_wake(timer->irq);
300
301	brcmstb_waketmr_clear_alarm(timer);
302
303	return ret;
304}
305#endif /* CONFIG_PM_SLEEP */
306
307static SIMPLE_DEV_PM_OPS(brcmstb_waketmr_pm_ops,
308			 brcmstb_waketmr_suspend, brcmstb_waketmr_resume);
309
310static const struct of_device_id brcmstb_waketmr_of_match[] = {
311	{ .compatible = "brcm,brcmstb-waketimer" },
312	{ /* sentinel */ },
313};
314
315static struct platform_driver brcmstb_waketmr_driver = {
316	.probe			= brcmstb_waketmr_probe,
317	.remove			= brcmstb_waketmr_remove,
318	.driver = {
319		.name		= "brcmstb-waketimer",
320		.pm		= &brcmstb_waketmr_pm_ops,
321		.of_match_table	= of_match_ptr(brcmstb_waketmr_of_match),
322	}
323};
324module_platform_driver(brcmstb_waketmr_driver);
325
326MODULE_LICENSE("GPL v2");
327MODULE_AUTHOR("Brian Norris");
328MODULE_AUTHOR("Markus Mayer");
329MODULE_DESCRIPTION("Wake-up timer driver for STB chips");