[linux-block.git] / drivers / rtc / rtc-brcmstb-waketimer.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright © 2014-2017 Broadcom
 */

#define pr_fmt(fmt)	KBUILD_MODNAME ": " fmt

#include <linux/clk.h>
#include <linux/device.h>
#include <linux/err.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/irqreturn.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/pm.h>
#include <linux/pm_wakeup.h>
#include <linux/reboot.h>
#include <linux/rtc.h>
#include <linux/stat.h>
#include <linux/suspend.h>

struct brcmstb_waketmr {
	struct rtc_device *rtc;
	struct device *dev;
	void __iomem *base;
	unsigned int wake_irq;
	unsigned int alarm_irq;
	struct notifier_block reboot_notifier;
	struct clk *clk;
	u32 rate;
	unsigned long rtc_alarm;
	bool alarm_en;
};

#define BRCMSTB_WKTMR_EVENT		0x00
#define  WKTMR_ALARM_EVENT		BIT(0)
#define BRCMSTB_WKTMR_COUNTER		0x04
#define BRCMSTB_WKTMR_ALARM		0x08
#define BRCMSTB_WKTMR_PRESCALER		0x0C
#define BRCMSTB_WKTMR_PRESCALER_VAL	0x10

#define BRCMSTB_WKTMR_DEFAULT_FREQ	27000000

static inline bool brcmstb_waketmr_is_pending(struct brcmstb_waketmr *timer)
{
	u32 reg;

	reg = readl_relaxed(timer->base + BRCMSTB_WKTMR_EVENT);
	return !!(reg & WKTMR_ALARM_EVENT);
}

static inline void brcmstb_waketmr_clear_alarm(struct brcmstb_waketmr *timer)
{
	u32 reg;

	if (timer->alarm_en && timer->alarm_irq)
		disable_irq(timer->alarm_irq);
	timer->alarm_en = false;
	reg = readl_relaxed(timer->base + BRCMSTB_WKTMR_COUNTER);
	writel_relaxed(reg - 1, timer->base + BRCMSTB_WKTMR_ALARM);
	writel_relaxed(WKTMR_ALARM_EVENT, timer->base + BRCMSTB_WKTMR_EVENT);
	(void)readl_relaxed(timer->base + BRCMSTB_WKTMR_EVENT);
}

static void brcmstb_waketmr_set_alarm(struct brcmstb_waketmr *timer,
				      unsigned int secs)
{
	unsigned int now;

	brcmstb_waketmr_clear_alarm(timer);

	/* Make sure we are actually counting in seconds */
	writel_relaxed(timer->rate, timer->base + BRCMSTB_WKTMR_PRESCALER);

	writel_relaxed(secs, timer->base + BRCMSTB_WKTMR_ALARM);
	now = readl_relaxed(timer->base + BRCMSTB_WKTMR_COUNTER);

	while ((int)(secs - now) <= 0 &&
		!brcmstb_waketmr_is_pending(timer)) {
		secs = now + 1;
		writel_relaxed(secs, timer->base + BRCMSTB_WKTMR_ALARM);
		now = readl_relaxed(timer->base + BRCMSTB_WKTMR_COUNTER);
	}
}

static irqreturn_t brcmstb_waketmr_irq(int irq, void *data)
{
	struct brcmstb_waketmr *timer = data;

	if (!timer->alarm_irq)
		pm_wakeup_event(timer->dev, 0);
	return IRQ_HANDLED;
}

static irqreturn_t brcmstb_alarm_irq(int irq, void *data)
{
	struct brcmstb_waketmr *timer = data;

	/* Ignore spurious interrupts */
	if (!brcmstb_waketmr_is_pending(timer))
		return IRQ_HANDLED;

	if (timer->alarm_en) {
		if (!device_may_wakeup(timer->dev))
			writel_relaxed(WKTMR_ALARM_EVENT,
				       timer->base + BRCMSTB_WKTMR_EVENT);
		rtc_update_irq(timer->rtc, 1, RTC_IRQF | RTC_AF);
	}

	return IRQ_HANDLED;
}

struct wktmr_time {
	u32 sec;
	u32 pre;
};

static void wktmr_read(struct brcmstb_waketmr *timer,
		       struct wktmr_time *t)
{
	u32 tmp;

	do {
		t->sec = readl_relaxed(timer->base + BRCMSTB_WKTMR_COUNTER);
		tmp = readl_relaxed(timer->base + BRCMSTB_WKTMR_PRESCALER_VAL);
	} while (tmp >= timer->rate);

	t->pre = timer->rate - tmp;
}

static int brcmstb_waketmr_prepare_suspend(struct brcmstb_waketmr *timer)
{
	struct device *dev = timer->dev;
	int ret;

	if (device_may_wakeup(dev)) {
		ret = enable_irq_wake(timer->wake_irq);
		if (ret) {
			dev_err(dev, "failed to enable wake-up interrupt\n");
			return ret;
		}
		if (timer->alarm_en && timer->alarm_irq) {
			ret = enable_irq_wake(timer->alarm_irq);
			if (ret) {
				dev_err(dev, "failed to enable rtc interrupt\n");
				disable_irq_wake(timer->wake_irq);
				return ret;
			}
		}
	}

	return 0;
}

/* If enabled as a wakeup-source, arm the timer when powering off */
static int brcmstb_waketmr_reboot(struct notifier_block *nb,
		unsigned long action, void *data)
{
	struct brcmstb_waketmr *timer;

	timer = container_of(nb, struct brcmstb_waketmr, reboot_notifier);

	/* Set timer for cold boot */
	if (action == SYS_POWER_OFF)
		brcmstb_waketmr_prepare_suspend(timer);

	return NOTIFY_DONE;
}

static int brcmstb_waketmr_gettime(struct device *dev,
				   struct rtc_time *tm)
{
	struct brcmstb_waketmr *timer = dev_get_drvdata(dev);
	struct wktmr_time now;

	wktmr_read(timer, &now);

	rtc_time64_to_tm(now.sec, tm);

	return 0;
}

static int brcmstb_waketmr_settime(struct device *dev,
				   struct rtc_time *tm)
{
	struct brcmstb_waketmr *timer = dev_get_drvdata(dev);
	time64_t sec;

	sec = rtc_tm_to_time64(tm);

	writel_relaxed(sec, timer->base + BRCMSTB_WKTMR_COUNTER);

	return 0;
}

static int brcmstb_waketmr_getalarm(struct device *dev,
				    struct rtc_wkalrm *alarm)
{
	struct brcmstb_waketmr *timer = dev_get_drvdata(dev);

	alarm->enabled = timer->alarm_en;
	rtc_time64_to_tm(timer->rtc_alarm, &alarm->time);

	alarm->pending = brcmstb_waketmr_is_pending(timer);

	return 0;
}

static int brcmstb_waketmr_alarm_enable(struct device *dev,
					unsigned int enabled)
{
	struct brcmstb_waketmr *timer = dev_get_drvdata(dev);

	if (enabled && !timer->alarm_en) {
		if ((int)(readl_relaxed(timer->base + BRCMSTB_WKTMR_COUNTER) -
		    readl_relaxed(timer->base + BRCMSTB_WKTMR_ALARM)) >= 0 &&
		    !brcmstb_waketmr_is_pending(timer))
			return -EINVAL;
		timer->alarm_en = true;
		if (timer->alarm_irq)
			enable_irq(timer->alarm_irq);
	} else if (!enabled && timer->alarm_en) {
		if (timer->alarm_irq)
			disable_irq(timer->alarm_irq);
		timer->alarm_en = false;
	}

	return 0;
}

static int brcmstb_waketmr_setalarm(struct device *dev,
				     struct rtc_wkalrm *alarm)
{
	struct brcmstb_waketmr *timer = dev_get_drvdata(dev);

	timer->rtc_alarm = rtc_tm_to_time64(&alarm->time);

	brcmstb_waketmr_set_alarm(timer, timer->rtc_alarm);

	return brcmstb_waketmr_alarm_enable(dev, alarm->enabled);
}

static const struct rtc_class_ops brcmstb_waketmr_ops = {
	.read_time	= brcmstb_waketmr_gettime,
	.set_time	= brcmstb_waketmr_settime,
	.read_alarm	= brcmstb_waketmr_getalarm,
	.set_alarm	= brcmstb_waketmr_setalarm,
	.alarm_irq_enable = brcmstb_waketmr_alarm_enable,
};

static int brcmstb_waketmr_probe(struct platform_device *pdev)
{
	struct device *dev = &pdev->dev;
	struct brcmstb_waketmr *timer;
	int ret;

	timer = devm_kzalloc(dev, sizeof(*timer), GFP_KERNEL);
	if (!timer)
		return -ENOMEM;

	platform_set_drvdata(pdev, timer);
	timer->dev = dev;

	timer->base = devm_platform_ioremap_resource(pdev, 0);
	if (IS_ERR(timer->base))
		return PTR_ERR(timer->base);

	timer->rtc = devm_rtc_allocate_device(dev);
	if (IS_ERR(timer->rtc))
		return PTR_ERR(timer->rtc);

	/*
	 * Set wakeup capability before requesting wakeup interrupt, so we can
	 * process boot-time "wakeups" (e.g., from S5 soft-off)
	 */
	device_init_wakeup(dev, true);

	ret = platform_get_irq(pdev, 0);
	if (ret < 0)
		return -ENODEV;
	timer->wake_irq = (unsigned int)ret;

	timer->clk = devm_clk_get(dev, NULL);
	if (!IS_ERR(timer->clk)) {
		ret = clk_prepare_enable(timer->clk);
		if (ret)
			return ret;
		timer->rate = clk_get_rate(timer->clk);
		if (!timer->rate)
			timer->rate = BRCMSTB_WKTMR_DEFAULT_FREQ;
	} else {
		timer->rate = BRCMSTB_WKTMR_DEFAULT_FREQ;
		timer->clk = NULL;
	}

	ret = devm_request_irq(dev, timer->wake_irq, brcmstb_waketmr_irq, 0,
			       "brcmstb-waketimer", timer);
	if (ret < 0)
		goto err_clk;

	brcmstb_waketmr_clear_alarm(timer);

	/* Attempt to initialize non-wake irq */
	ret = platform_get_irq(pdev, 1);
	if (ret > 0) {
		timer->alarm_irq = (unsigned int)ret;
		ret = devm_request_irq(dev, timer->alarm_irq, brcmstb_alarm_irq,
				       IRQF_NO_AUTOEN, "brcmstb-waketimer-rtc",
				       timer);
		if (ret < 0)
			timer->alarm_irq = 0;
	}

	timer->reboot_notifier.notifier_call = brcmstb_waketmr_reboot;
	register_reboot_notifier(&timer->reboot_notifier);

	timer->rtc->ops = &brcmstb_waketmr_ops;
	timer->rtc->range_max = U32_MAX;

	ret = devm_rtc_register_device(timer->rtc);
	if (ret)
		goto err_notifier;

	return 0;

err_notifier:
	unregister_reboot_notifier(&timer->reboot_notifier);

err_clk:
	clk_disable_unprepare(timer->clk);

	return ret;
}

static int brcmstb_waketmr_remove(struct platform_device *pdev)
{
	struct brcmstb_waketmr *timer = dev_get_drvdata(&pdev->dev);

	unregister_reboot_notifier(&timer->reboot_notifier);
	clk_disable_unprepare(timer->clk);

	return 0;
}

#ifdef CONFIG_PM_SLEEP
static int brcmstb_waketmr_suspend(struct device *dev)
{
	struct brcmstb_waketmr *timer = dev_get_drvdata(dev);

	return brcmstb_waketmr_prepare_suspend(timer);
}

static int brcmstb_waketmr_resume(struct device *dev)
{
	struct brcmstb_waketmr *timer = dev_get_drvdata(dev);
	int ret;

	if (!device_may_wakeup(dev))
		return 0;

	ret = disable_irq_wake(timer->wake_irq);
	if (timer->alarm_en && timer->alarm_irq)
		disable_irq_wake(timer->alarm_irq);

	brcmstb_waketmr_clear_alarm(timer);

	return ret;
}
#endif /* CONFIG_PM_SLEEP */

static SIMPLE_DEV_PM_OPS(brcmstb_waketmr_pm_ops,
			 brcmstb_waketmr_suspend, brcmstb_waketmr_resume);

static const __maybe_unused struct of_device_id brcmstb_waketmr_of_match[] = {
	{ .compatible = "brcm,brcmstb-waketimer" },
	{ /* sentinel */ },
};

static struct platform_driver brcmstb_waketmr_driver = {
	.probe			= brcmstb_waketmr_probe,
	.remove			= brcmstb_waketmr_remove,
	.driver = {
		.name		= "brcmstb-waketimer",
		.pm		= &brcmstb_waketmr_pm_ops,
		.of_match_table	= of_match_ptr(brcmstb_waketmr_of_match),
	}
};
module_platform_driver(brcmstb_waketmr_driver);

MODULE_LICENSE("GPL v2");
MODULE_AUTHOR("Brian Norris");
MODULE_AUTHOR("Markus Mayer");
MODULE_AUTHOR("Doug Berger");
MODULE_DESCRIPTION("Wake-up timer driver for STB chips");
Commit	Line	Data
1802d0be	1	// SPDX-License-Identifier: GPL-2.0-only
c4f07ece BN	2	/*
c4f07ece BN	3	* Copyright © 2014-2017 Broadcom
c4f07ece BN	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
	26	struct brcmstb_waketmr {
	27	struct rtc_device *rtc;
	28	struct device *dev;
	29	void __iomem *base;
eae258ed	30	unsigned int wake_irq;
24304a87	31	unsigned int alarm_irq;
c4f07ece BN	32	struct notifier_block reboot_notifier;
	33	struct clk *clk;
	34	u32 rate;
516ae02c DB	35	unsigned long rtc_alarm;
516ae02c DB	36	bool alarm_en;
c4f07ece BN	37	};
	38
	39	#define BRCMSTB_WKTMR_EVENT 0x00
90226f6b	40	#define WKTMR_ALARM_EVENT BIT(0)
c4f07ece BN	41	#define BRCMSTB_WKTMR_COUNTER 0x04
	42	#define BRCMSTB_WKTMR_ALARM 0x08
	43	#define BRCMSTB_WKTMR_PRESCALER 0x0C
	44	#define BRCMSTB_WKTMR_PRESCALER_VAL 0x10
	45
	46	#define BRCMSTB_WKTMR_DEFAULT_FREQ 27000000
	47
90226f6b DB	48	static inline bool brcmstb_waketmr_is_pending(struct brcmstb_waketmr *timer)
	49	{
	50	u32 reg;
	51
	52	reg = readl_relaxed(timer->base + BRCMSTB_WKTMR_EVENT);
	53	return !!(reg & WKTMR_ALARM_EVENT);
	54	}
	55
c4f07ece BN	56	static inline void brcmstb_waketmr_clear_alarm(struct brcmstb_waketmr *timer)
c4f07ece BN	57	{
516ae02c DB	58	u32 reg;
516ae02c DB	59
24304a87 DB	60	if (timer->alarm_en && timer->alarm_irq)
24304a87 DB	61	disable_irq(timer->alarm_irq);
516ae02c DB	62	timer->alarm_en = false;
	63	reg = readl_relaxed(timer->base + BRCMSTB_WKTMR_COUNTER);
	64	writel_relaxed(reg - 1, timer->base + BRCMSTB_WKTMR_ALARM);
90226f6b	65	writel_relaxed(WKTMR_ALARM_EVENT, timer->base + BRCMSTB_WKTMR_EVENT);
c4f07ece BN	66	(void)readl_relaxed(timer->base + BRCMSTB_WKTMR_EVENT);
	67	}
	68
	69	static void brcmstb_waketmr_set_alarm(struct brcmstb_waketmr *timer,
	70	unsigned int secs)
	71	{
516ae02c DB	72	unsigned int now;
516ae02c DB	73
c4f07ece BN	74	brcmstb_waketmr_clear_alarm(timer);
c4f07ece BN	75
58d3d5e7 JC	76	/* Make sure we are actually counting in seconds */
	77	writel_relaxed(timer->rate, timer->base + BRCMSTB_WKTMR_PRESCALER);
	78
516ae02c DB	79	writel_relaxed(secs, timer->base + BRCMSTB_WKTMR_ALARM);
	80	now = readl_relaxed(timer->base + BRCMSTB_WKTMR_COUNTER);
	81
	82	while ((int)(secs - now) <= 0 &&
	83	!brcmstb_waketmr_is_pending(timer)) {
	84	secs = now + 1;
	85	writel_relaxed(secs, timer->base + BRCMSTB_WKTMR_ALARM);
	86	now = readl_relaxed(timer->base + BRCMSTB_WKTMR_COUNTER);
	87	}
c4f07ece BN	88	}
	89
	90	static irqreturn_t brcmstb_waketmr_irq(int irq, void *data)
	91	{
	92	struct brcmstb_waketmr *timer = data;
	93
24304a87 DB	94	if (!timer->alarm_irq)
	95	pm_wakeup_event(timer->dev, 0);
	96	return IRQ_HANDLED;
	97	}
	98
	99	static irqreturn_t brcmstb_alarm_irq(int irq, void *data)
	100	{
	101	struct brcmstb_waketmr *timer = data;
	102
	103	/* Ignore spurious interrupts */
	104	if (!brcmstb_waketmr_is_pending(timer))
	105	return IRQ_HANDLED;
	106
	107	if (timer->alarm_en) {
	108	if (!device_may_wakeup(timer->dev))
	109	writel_relaxed(WKTMR_ALARM_EVENT,
	110	timer->base + BRCMSTB_WKTMR_EVENT);
	111	rtc_update_irq(timer->rtc, 1, RTC_IRQF \| RTC_AF);
	112	}
c4f07ece BN	113
	114	return IRQ_HANDLED;
	115	}
	116
	117	struct wktmr_time {
	118	u32 sec;
	119	u32 pre;
	120	};
	121
	122	static void wktmr_read(struct brcmstb_waketmr *timer,
	123	struct wktmr_time *t)
	124	{
	125	u32 tmp;
	126
	127	do {
	128	t->sec = readl_relaxed(timer->base + BRCMSTB_WKTMR_COUNTER);
	129	tmp = readl_relaxed(timer->base + BRCMSTB_WKTMR_PRESCALER_VAL);
	130	} while (tmp >= timer->rate);
	131
	132	t->pre = timer->rate - tmp;
	133	}
	134
	135	static int brcmstb_waketmr_prepare_suspend(struct brcmstb_waketmr *timer)
	136	{
	137	struct device *dev = timer->dev;
24304a87	138	int ret;
c4f07ece BN	139
c4f07ece BN	140	if (device_may_wakeup(dev)) {
eae258ed	141	ret = enable_irq_wake(timer->wake_irq);
c4f07ece BN	142	if (ret) {
	143	dev_err(dev, "failed to enable wake-up interrupt\n");
	144	return ret;
	145	}
24304a87 DB	146	if (timer->alarm_en && timer->alarm_irq) {
	147	ret = enable_irq_wake(timer->alarm_irq);
	148	if (ret) {
	149	dev_err(dev, "failed to enable rtc interrupt\n");
	150	disable_irq_wake(timer->wake_irq);
	151	return ret;
	152	}
	153	}
c4f07ece BN	154	}
c4f07ece BN	155
24304a87	156	return 0;
c4f07ece BN	157	}
	158
	159	/* If enabled as a wakeup-source, arm the timer when powering off */
	160	static int brcmstb_waketmr_reboot(struct notifier_block *nb,
	161	unsigned long action, void *data)
	162	{
	163	struct brcmstb_waketmr *timer;
	164
	165	timer = container_of(nb, struct brcmstb_waketmr, reboot_notifier);
	166
	167	/* Set timer for cold boot */
	168	if (action == SYS_POWER_OFF)
	169	brcmstb_waketmr_prepare_suspend(timer);
	170
	171	return NOTIFY_DONE;
	172	}
	173
	174	static int brcmstb_waketmr_gettime(struct device *dev,
	175	struct rtc_time *tm)
	176	{
	177	struct brcmstb_waketmr *timer = dev_get_drvdata(dev);
	178	struct wktmr_time now;
	179
	180	wktmr_read(timer, &now);
	181
9a8f2d12	182	rtc_time64_to_tm(now.sec, tm);
c4f07ece BN	183
	184	return 0;
	185	}
	186
	187	static int brcmstb_waketmr_settime(struct device *dev,
	188	struct rtc_time *tm)
	189	{
	190	struct brcmstb_waketmr *timer = dev_get_drvdata(dev);
	191	time64_t sec;
	192
	193	sec = rtc_tm_to_time64(tm);
	194
c4f07ece BN	195	writel_relaxed(sec, timer->base + BRCMSTB_WKTMR_COUNTER);
	196
	197	return 0;
	198	}
	199
	200	static int brcmstb_waketmr_getalarm(struct device *dev,
	201	struct rtc_wkalrm *alarm)
	202	{
	203	struct brcmstb_waketmr *timer = dev_get_drvdata(dev);
c4f07ece	204
516ae02c DB	205	alarm->enabled = timer->alarm_en;
516ae02c DB	206	rtc_time64_to_tm(timer->rtc_alarm, &alarm->time);
c4f07ece	207
90226f6b	208	alarm->pending = brcmstb_waketmr_is_pending(timer);
c4f07ece BN	209
	210	return 0;
	211	}
	212
2cd98b22 DB	213	static int brcmstb_waketmr_alarm_enable(struct device *dev,
	214	unsigned int enabled)
	215	{
516ae02c DB	216	struct brcmstb_waketmr *timer = dev_get_drvdata(dev);
	217
	218	if (enabled && !timer->alarm_en) {
	219	if ((int)(readl_relaxed(timer->base + BRCMSTB_WKTMR_COUNTER) -
	220	readl_relaxed(timer->base + BRCMSTB_WKTMR_ALARM)) >= 0 &&
	221	!brcmstb_waketmr_is_pending(timer))
	222	return -EINVAL;
	223	timer->alarm_en = true;
24304a87 DB	224	if (timer->alarm_irq)
24304a87 DB	225	enable_irq(timer->alarm_irq);
516ae02c	226	} else if (!enabled && timer->alarm_en) {
24304a87 DB	227	if (timer->alarm_irq)
24304a87 DB	228	disable_irq(timer->alarm_irq);
516ae02c DB	229	timer->alarm_en = false;
	230	}
	231
2cd98b22 DB	232	return 0;
	233	}
	234
c4f07ece BN	235	static int brcmstb_waketmr_setalarm(struct device *dev,
	236	struct rtc_wkalrm *alarm)
	237	{
	238	struct brcmstb_waketmr *timer = dev_get_drvdata(dev);
c4f07ece	239
516ae02c	240	timer->rtc_alarm = rtc_tm_to_time64(&alarm->time);
c4f07ece	241
516ae02c	242	brcmstb_waketmr_set_alarm(timer, timer->rtc_alarm);
c4f07ece	243
2cd98b22	244	return brcmstb_waketmr_alarm_enable(dev, alarm->enabled);
c4f07ece BN	245	}
	246
	247	static const struct rtc_class_ops brcmstb_waketmr_ops = {
	248	.read_time = brcmstb_waketmr_gettime,
	249	.set_time = brcmstb_waketmr_settime,
	250	.read_alarm = brcmstb_waketmr_getalarm,
	251	.set_alarm = brcmstb_waketmr_setalarm,
	252	.alarm_irq_enable = brcmstb_waketmr_alarm_enable,
	253	};
	254
	255	static int brcmstb_waketmr_probe(struct platform_device *pdev)
	256	{
	257	struct device *dev = &pdev->dev;
	258	struct brcmstb_waketmr *timer;
c4f07ece BN	259	int ret;
	260
	261	timer = devm_kzalloc(dev, sizeof(*timer), GFP_KERNEL);
	262	if (!timer)
	263	return -ENOMEM;
	264
	265	platform_set_drvdata(pdev, timer);
	266	timer->dev = dev;
	267
09ef18bc	268	timer->base = devm_platform_ioremap_resource(pdev, 0);
c4f07ece BN	269	if (IS_ERR(timer->base))
	270	return PTR_ERR(timer->base);
	271
2abf286a AB	272	timer->rtc = devm_rtc_allocate_device(dev);
	273	if (IS_ERR(timer->rtc))
	274	return PTR_ERR(timer->rtc);
	275
c4f07ece BN	276	/*
	277	* Set wakeup capability before requesting wakeup interrupt, so we can
	278	* process boot-time "wakeups" (e.g., from S5 soft-off)
	279	*/
2cd98b22	280	device_init_wakeup(dev, true);
c4f07ece	281
eae258ed DB	282	ret = platform_get_irq(pdev, 0);
eae258ed DB	283	if (ret < 0)
c4f07ece	284	return -ENODEV;
eae258ed	285	timer->wake_irq = (unsigned int)ret;
c4f07ece BN	286
	287	timer->clk = devm_clk_get(dev, NULL);
	288	if (!IS_ERR(timer->clk)) {
	289	ret = clk_prepare_enable(timer->clk);
	290	if (ret)
	291	return ret;
	292	timer->rate = clk_get_rate(timer->clk);
	293	if (!timer->rate)
	294	timer->rate = BRCMSTB_WKTMR_DEFAULT_FREQ;
	295	} else {
	296	timer->rate = BRCMSTB_WKTMR_DEFAULT_FREQ;
	297	timer->clk = NULL;
	298	}
	299
eae258ed	300	ret = devm_request_irq(dev, timer->wake_irq, brcmstb_waketmr_irq, 0,
c4f07ece BN	301	"brcmstb-waketimer", timer);
c4f07ece BN	302	if (ret < 0)
f2eef045	303	goto err_clk;
c4f07ece	304
24304a87 DB	305	brcmstb_waketmr_clear_alarm(timer);
	306
	307	/* Attempt to initialize non-wake irq */
	308	ret = platform_get_irq(pdev, 1);
	309	if (ret > 0) {
	310	timer->alarm_irq = (unsigned int)ret;
	311	ret = devm_request_irq(dev, timer->alarm_irq, brcmstb_alarm_irq,
	312	IRQF_NO_AUTOEN, "brcmstb-waketimer-rtc",
	313	timer);
	314	if (ret < 0)
	315	timer->alarm_irq = 0;
	316	}
	317
c4f07ece BN	318	timer->reboot_notifier.notifier_call = brcmstb_waketmr_reboot;
	319	register_reboot_notifier(&timer->reboot_notifier);
	320
2abf286a	321	timer->rtc->ops = &brcmstb_waketmr_ops;
ded67666	322	timer->rtc->range_max = U32_MAX;
2abf286a	323
fdcfd854	324	ret = devm_rtc_register_device(timer->rtc);
44c638ce	325	if (ret)
f2eef045	326	goto err_notifier;
c4f07ece	327
f2eef045 AK	328	return 0;
	329
	330	err_notifier:
	331	unregister_reboot_notifier(&timer->reboot_notifier);
	332
	333	err_clk:
910d002d	334	clk_disable_unprepare(timer->clk);
f2eef045	335
c4f07ece BN	336	return ret;
	337	}
	338
	339	static int brcmstb_waketmr_remove(struct platform_device *pdev)
	340	{
	341	struct brcmstb_waketmr *timer = dev_get_drvdata(&pdev->dev);
	342
	343	unregister_reboot_notifier(&timer->reboot_notifier);
94303f89	344	clk_disable_unprepare(timer->clk);
c4f07ece BN	345
	346	return 0;
	347	}
	348
	349	#ifdef CONFIG_PM_SLEEP
	350	static int brcmstb_waketmr_suspend(struct device *dev)
	351	{
	352	struct brcmstb_waketmr *timer = dev_get_drvdata(dev);
	353
	354	return brcmstb_waketmr_prepare_suspend(timer);
	355	}
	356
	357	static int brcmstb_waketmr_resume(struct device *dev)
	358	{
	359	struct brcmstb_waketmr *timer = dev_get_drvdata(dev);
	360	int ret;
	361
	362	if (!device_may_wakeup(dev))
	363	return 0;
	364
eae258ed	365	ret = disable_irq_wake(timer->wake_irq);
24304a87 DB	366	if (timer->alarm_en && timer->alarm_irq)
24304a87 DB	367	disable_irq_wake(timer->alarm_irq);
c4f07ece BN	368
	369	brcmstb_waketmr_clear_alarm(timer);
	370
	371	return ret;
	372	}
	373	#endif /* CONFIG_PM_SLEEP */
	374
	375	static SIMPLE_DEV_PM_OPS(brcmstb_waketmr_pm_ops,
	376	brcmstb_waketmr_suspend, brcmstb_waketmr_resume);
	377
ae1247f7	378	static const __maybe_unused struct of_device_id brcmstb_waketmr_of_match[] = {
c4f07ece BN	379	{ .compatible = "brcm,brcmstb-waketimer" },
	380	{ /* sentinel */ },
	381	};
	382
	383	static struct platform_driver brcmstb_waketmr_driver = {
	384	.probe = brcmstb_waketmr_probe,
	385	.remove = brcmstb_waketmr_remove,
	386	.driver = {
	387	.name = "brcmstb-waketimer",
	388	.pm = &brcmstb_waketmr_pm_ops,
	389	.of_match_table = of_match_ptr(brcmstb_waketmr_of_match),
	390	}
	391	};
	392	module_platform_driver(brcmstb_waketmr_driver);
	393
	394	MODULE_LICENSE("GPL v2");
	395	MODULE_AUTHOR("Brian Norris");
	396	MODULE_AUTHOR("Markus Mayer");
24304a87	397	MODULE_AUTHOR("Doug Berger");
c4f07ece	398	MODULE_DESCRIPTION("Wake-up timer driver for STB chips");