rtc-tps6586x.c | Explore in Territory

// SPDX-License-Identifier: GPL-2.0-only
/*
 * rtc-tps6586x.c: RTC driver for TI PMIC TPS6586X
 *
 * Copyright (c) 2012, NVIDIA Corporation.
 *
 * Author: Laxman Dewangan <[email protected]>
 */

#include <linux/device.h>
#include <linux/err.h>
#include <linux/init.h>
#include <linux/irq.h>
#include <linux/kernel.h>
#include <linux/mfd/tps6586x.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/pm_runtime.h>
#include <linux/rtc.h>
#include <linux/slab.h>

#define RTC_CTRL …
#define POR_RESET_N …
#define OSC_SRC_SEL …
#define RTC_ENABLE …
#define RTC_BUF_ENABLE …
#define PRE_BYPASS …
#define CL_SEL_MASK …
#define CL_SEL_POS …
#define RTC_ALARM1_HI …
#define RTC_COUNT4 …

/* start a PMU RTC access by reading the register prior to the RTC_COUNT4 */
#define RTC_COUNT4_DUMMYREAD …

/*only 14-bits width in second*/
#define ALM1_VALID_RANGE_IN_SEC …

#define TPS6586X_RTC_CL_SEL_1_5PF …
#define TPS6586X_RTC_CL_SEL_6_5PF …
#define TPS6586X_RTC_CL_SEL_7_5PF …
#define TPS6586X_RTC_CL_SEL_12_5PF …

struct tps6586x_rtc { … };

static inline struct device *to_tps6586x_dev(struct device *dev)
{ … }

static int tps6586x_rtc_read_time(struct device *dev, struct rtc_time *tm)
{ … }

static int tps6586x_rtc_set_time(struct device *dev, struct rtc_time *tm)
{ … }

static int tps6586x_rtc_alarm_irq_enable(struct device *dev,
			 unsigned int enabled)
{ … }

static int tps6586x_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
{ … }

static int tps6586x_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
{ … }

static const struct rtc_class_ops tps6586x_rtc_ops = …;

static irqreturn_t tps6586x_rtc_irq(int irq, void *data)
{ … }

static int tps6586x_rtc_probe(struct platform_device *pdev)
{
	struct device *tps_dev = to_tps6586x_dev(&pdev->dev);
	struct tps6586x_rtc *rtc;
	int ret;

	rtc = devm_kzalloc(&pdev->dev, sizeof(*rtc), GFP_KERNEL);
	if (!rtc)
		return -ENOMEM;

	rtc->dev = &pdev->dev;
	rtc->irq = platform_get_irq(pdev, 0);

	/* 1 kHz tick mode, enable tick counting */
	ret = tps6586x_update(tps_dev, RTC_CTRL,
		RTC_ENABLE | OSC_SRC_SEL |
		((TPS6586X_RTC_CL_SEL_1_5PF << CL_SEL_POS) & CL_SEL_MASK),
		RTC_ENABLE | OSC_SRC_SEL | PRE_BYPASS | CL_SEL_MASK);
	if (ret < 0) {
		dev_err(&pdev->dev, "unable to start counter\n");
		return ret;
	}

	device_init_wakeup(&pdev->dev, 1);

	platform_set_drvdata(pdev, rtc);
	rtc->rtc = devm_rtc_allocate_device(&pdev->dev);
	if (IS_ERR(rtc->rtc)) {
		ret = PTR_ERR(rtc->rtc);
		goto fail_rtc_register;
	}

	rtc->rtc->ops = &tps6586x_rtc_ops;
	rtc->rtc->range_max = (1ULL << 30) - 1; /* 30-bit seconds */
	rtc->rtc->alarm_offset_max = ALM1_VALID_RANGE_IN_SEC;
	rtc->rtc->start_secs = mktime64(2009, 1, 1, 0, 0, 0);
	rtc->rtc->set_start_time = true;

	irq_set_status_flags(rtc->irq, IRQ_NOAUTOEN);

	ret = devm_request_threaded_irq(&pdev->dev, rtc->irq, NULL,
				tps6586x_rtc_irq,
				IRQF_ONESHOT,
				dev_name(&pdev->dev), rtc);
	if (ret < 0) {
		dev_err(&pdev->dev, "request IRQ(%d) failed with ret %d\n",
				rtc->irq, ret);
		goto fail_rtc_register;
	}

	ret = devm_rtc_register_device(rtc->rtc);
	if (ret)
		goto fail_rtc_register;

	return 0;

fail_rtc_register:
	tps6586x_update(tps_dev, RTC_CTRL, 0,
		RTC_ENABLE | OSC_SRC_SEL | PRE_BYPASS | CL_SEL_MASK);
	return ret;
};

static void tps6586x_rtc_remove(struct platform_device *pdev)
{ … }

#ifdef CONFIG_PM_SLEEP
static int tps6586x_rtc_suspend(struct device *dev)
{ … }

static int tps6586x_rtc_resume(struct device *dev)
{ … }
#endif

static SIMPLE_DEV_PM_OPS(tps6586x_pm_ops, tps6586x_rtc_suspend,
			tps6586x_rtc_resume);

static struct platform_driver tps6586x_rtc_driver = …;
module_platform_driver(…) …;

MODULE_ALIAS(…) …;
MODULE_DESCRIPTION(…) …;
MODULE_AUTHOR(…) …;
MODULE_LICENSE(…) …;
linux/drivers/rtc/rtc-tps6586x.c
