drivers/rtc/rtc-atcrtc100.c - linux/kernel/git/dtor/input - Git at Google


            
            // SPDX-License-Identifier: GPL-2.0-or-later

            
            /*

            
             * Driver for Andes ATCRTC100 real time clock.

            
             *

            
             * Copyright (C) 2025 Andes Technology Corporation

            
             */


            #include <linux/bitfield.h>

            
            #include <linux/delay.h>

            
            #include <linux/interrupt.h>

            
            #include <linux/math64.h>

            
            #include <linux/module.h>

            
            #include <linux/of.h>

            
            #include <linux/platform_device.h>

            
            #include <linux/pm_wakeirq.h>

            
            #include <linux/regmap.h>

            
            #include <linux/rtc.h>

            
            #include <linux/workqueue.h>


            /* Register Offsets */

            
            #define RTC_ID		0x00	/* ID and Revision Register */

            
            #define RTC_RSV		0x04	/* Reserved Register */

            
            #define RTC_CNT		0x10	/* Counter Register */

            
            #define RTC_ALM		0x14	/* Alarm Register */

            
            #define RTC_CR		0x18	/* Control Register */

            
            #define RTC_STA		0x1C	/* Status Register */

            
            #define RTC_TRIM	0x20	/* Digital Trimming Register */


            /* RTC_ID Register */

            
            #define ID_MSK		GENMASK(31, 8)

            
            #define ID_ATCRTC100	0x030110


            /* RTC_CNT and RTC_ALM Register Fields */

            
            #define SEC_MSK		GENMASK(5, 0)

            
            #define MIN_MSK		GENMASK(11, 6)

            
            #define HOUR_MSK	GENMASK(16, 12)

            
            #define DAY_MSK		GENMASK(31, 17)

            
            #define RTC_SEC_GET(x)	FIELD_GET(SEC_MSK, x)

            
            #define RTC_MIN_GET(x)	FIELD_GET(MIN_MSK, x)

            
            #define RTC_HOUR_GET(x)	FIELD_GET(HOUR_MSK, x)

            
            #define RTC_DAY_GET(x)	FIELD_GET(DAY_MSK, x)

            
            #define RTC_SEC_SET(x)	FIELD_PREP(SEC_MSK, x)

            
            #define RTC_MIN_SET(x)	FIELD_PREP(MIN_MSK, x)

            
            #define RTC_HOUR_SET(x)	FIELD_PREP(HOUR_MSK, x)

            
            #define RTC_DAY_SET(x)	FIELD_PREP(DAY_MSK, x)


            /* RTC_CR Register Bits */

            
            #define RTC_EN		BIT(0)	/* RTC Enable */

            
            #define ALARM_WAKEUP	BIT(1)	/* Alarm Wakeup Enable */

            
            #define ALARM_INT	BIT(2)	/* Alarm Interrupt Enable */

            
            #define DAY_INT		BIT(3)	/* Day Interrupt Enable */

            
            #define HOUR_INT	BIT(4)	/* Hour Interrupt Enable */

            
            #define MIN_INT		BIT(5)	/* Minute Interrupt Enable */

            
            #define SEC_INT		BIT(6)	/* Second Periodic Interrupt Enable */

            
            #define HSEC_INT	BIT(7)	/* Half-Second Periodic Interrupt Enable */


            /* RTC_STA Register Bits */

            
            #define WRITE_DONE	BIT(16)	/* Register write completion status */


            /* Time conversion macro */

            
            #define ATCRTC_TIME_TO_SEC(D, H, M, S)	\

            
            	((time64_t)(D) * 86400 + (H) * 3600 + (M) * 60 + (S))


            /* Timeout for waiting for the write_done bit */

            
            #define ATCRTC_TIMEOUT_US		1000000

            
            #define ATCRTC_TIMEOUT_USLEEP_MIN	20

            
            #define ATCRTC_TIMEOUT_USLEEP_MAX	30


            struct atcrtc_dev {

            
            	struct rtc_device	*rtc_dev;

            
            	struct regmap		*regmap;

            
            	struct work_struct	rtc_work;

            
            	unsigned int		alarm_irq;

            
            	bool			alarm_en;

            
            };


            static const struct regmap_config atcrtc_regmap_config = {

            
            	.reg_bits = 32,

            
            	.reg_stride = 4,

            
            	.val_bits = 32,

            
            	.max_register = RTC_TRIM,

            
            	.cache_type = REGCACHE_NONE,

            
            };


            /**

            
             * atcrtc_check_write_done - Wait for RTC registers to be synchronized.

            
             * @rtc: Pointer to the atcrtc_dev structure.

            
             *

            
             * The WriteDone bit in the status register indicates the synchronization

            
             * progress of RTC register updates. This bit is cleared to zero whenever

            
             * any RTC control register (Counter, Alarm, Control, etc.) is written.

            
             * It returns to one only after all previous updates have been fully

            
             * synchronized to the RTC clock domain. This function polls the WriteDone

            
             * bit with a timeout to ensure the device is ready for the next operation.

            
             *

            
             * Return: 0 on success, or -EBUSY on timeout.

            
             */

            
            static int atcrtc_check_write_done(struct atcrtc_dev *rtc)

            
            {

            
            	unsigned int val;


            	/*

            
            	 * Using read_poll_timeout is more efficient than a manual loop

            
            	 * with usleep_range.

            
            	 */

            
            	return regmap_read_poll_timeout(rtc->regmap, RTC_STA, val,

            
            					val & WRITE_DONE,

            
            					ATCRTC_TIMEOUT_USLEEP_MIN,

            
            					ATCRTC_TIMEOUT_US);

            
            }


            static irqreturn_t atcrtc_alarm_isr(int irq, void *dev)

            
            {

            
            	struct atcrtc_dev *rtc = dev;

            
            	unsigned int status;


            	regmap_read(rtc->regmap, RTC_STA, &status);

            
            	if (status & ALARM_INT) {

            
            		regmap_write(rtc->regmap, RTC_STA, ALARM_INT);

            
            		rtc->alarm_en = false;

            
            		schedule_work(&rtc->rtc_work);

            
            		rtc_update_irq(rtc->rtc_dev, 1, RTC_AF | RTC_IRQF);

            
            		return IRQ_HANDLED;

            
            	}

            
            	return IRQ_NONE;

            
            }


            static int atcrtc_alarm_irq_enable(struct device *dev, unsigned int enable)

            
            {

            
            	struct atcrtc_dev *rtc = dev_get_drvdata(dev);

            
            	unsigned int mask;

            
            	int ret;


            	ret = atcrtc_check_write_done(rtc);

            
            	if (ret)

            
            		return ret;


            	mask = ALARM_WAKEUP | ALARM_INT;

            
            	regmap_update_bits(rtc->regmap, RTC_CR, mask, enable ? mask : 0);


            	return 0;

            
            }


            static void atcrtc_alarm_clear(struct work_struct *work)

            
            {

            
            	struct atcrtc_dev *rtc =

            
            		container_of(work, struct atcrtc_dev, rtc_work);

            
            	int ret;


            	rtc_lock(rtc->rtc_dev);


            	if (!rtc->alarm_en) {

            
            		ret = atcrtc_check_write_done(rtc);

            
            		if (ret)

            
            			dev_info(&rtc->rtc_dev->dev,

            
            				 "failed to sync before clearing alarm: %d\n",

            
            				 ret);

            
            		else

            
            			regmap_update_bits(rtc->regmap, RTC_CR,

            
            					   ALARM_WAKEUP | ALARM_INT, 0);

            
            	}

            
            	rtc_unlock(rtc->rtc_dev);

            
            }


            static int atcrtc_read_time(struct device *dev, struct rtc_time *tm)

            
            {

            
            	struct atcrtc_dev *rtc = dev_get_drvdata(dev);

            
            	time64_t time;

            
            	unsigned int rtc_cnt;


            	if (!regmap_test_bits(rtc->regmap, RTC_CR, RTC_EN))

            
            		return -EIO;


            	regmap_read(rtc->regmap, RTC_CNT, &rtc_cnt);

            
            	time = ATCRTC_TIME_TO_SEC(RTC_DAY_GET(rtc_cnt),

            
            				  RTC_HOUR_GET(rtc_cnt),

            
            				  RTC_MIN_GET(rtc_cnt),

            
            				  RTC_SEC_GET(rtc_cnt));

            
            	rtc_time64_to_tm(time, tm);


            	return 0;

            
            }


            static int atcrtc_set_time(struct device *dev, struct rtc_time *tm)

            
            {

            
            	struct atcrtc_dev *rtc = dev_get_drvdata(dev);

            
            	time64_t time;

            
            	unsigned int counter;

            
            	unsigned int day;

            
            	int ret;


            	time = rtc_tm_to_time64(tm);

            
            	day = div_s64(time, 86400);

            
            	counter = RTC_DAY_SET(day) |

            
            		  RTC_HOUR_SET(tm->tm_hour) |

            
            		  RTC_MIN_SET(tm->tm_min) |

            
            		  RTC_SEC_SET(tm->tm_sec);

            
            	ret = atcrtc_check_write_done(rtc);

            
            	if (ret)

            
            		return ret;

            
            	regmap_write(rtc->regmap, RTC_CNT, counter);


            	ret = atcrtc_check_write_done(rtc);

            
            	if (ret)

            
            		return ret;

            
            	regmap_update_bits(rtc->regmap, RTC_CR, RTC_EN, RTC_EN);


            	return 0;

            
            }


            static int atcrtc_read_alarm(struct device *dev, struct rtc_wkalrm *wkalrm)

            
            {

            
            	struct atcrtc_dev *rtc = dev_get_drvdata(dev);

            
            	struct rtc_time *tm = &wkalrm->time;

            
            	unsigned int rtc_alarm;


            	wkalrm->enabled = regmap_test_bits(rtc->regmap, RTC_CR, ALARM_INT);

            
            	regmap_read(rtc->regmap, RTC_ALM, &rtc_alarm);

            
            	tm->tm_hour = RTC_HOUR_GET(rtc_alarm);

            
            	tm->tm_min = RTC_MIN_GET(rtc_alarm);

            
            	tm->tm_sec = RTC_SEC_GET(rtc_alarm);


            	/* The RTC alarm does not support day/month/year fields */

            
            	tm->tm_mday = -1;

            
            	tm->tm_mon = -1;

            
            	tm->tm_year = -1;


            	return 0;

            
            }


            static int atcrtc_set_alarm(struct device *dev, struct rtc_wkalrm *wkalrm)

            
            {

            
            	struct atcrtc_dev *rtc = dev_get_drvdata(dev);

            
            	struct rtc_time *tm = &wkalrm->time;

            
            	unsigned int rtc_alarm;

            
            	int ret;


            	/* Disable alarm first before setting a new one */

            
            	ret = atcrtc_alarm_irq_enable(dev, 0);

            
            	if (ret)

            
            		return ret;


            	rtc->alarm_en = false;


            	rtc_alarm = RTC_SEC_SET(tm->tm_sec) |

            
            		    RTC_MIN_SET(tm->tm_min) |

            
            		    RTC_HOUR_SET(tm->tm_hour);


            	ret = atcrtc_check_write_done(rtc);

            
            	if (ret)

            
            		return ret;


            	regmap_write(rtc->regmap, RTC_ALM, rtc_alarm);


            	rtc->alarm_en = wkalrm->enabled;

            
            	ret = atcrtc_alarm_irq_enable(dev, wkalrm->enabled);


            	return ret;

            
            }


            static const struct rtc_class_ops rtc_ops = {

            
            	.read_time = atcrtc_read_time,

            
            	.set_time = atcrtc_set_time,

            
            	.read_alarm = atcrtc_read_alarm,

            
            	.set_alarm = atcrtc_set_alarm,

            
            	.alarm_irq_enable = atcrtc_alarm_irq_enable,

            
            };


            static int atcrtc_probe(struct platform_device *pdev)

            
            {

            
            	struct atcrtc_dev *atcrtc_dev;

            
            	void __iomem *reg_base;

            
            	unsigned int rtc_id;

            
            	int ret;


            	atcrtc_dev = devm_kzalloc(&pdev->dev, sizeof(*atcrtc_dev), GFP_KERNEL);

            
            	if (!atcrtc_dev)

            
            		return -ENOMEM;

            
            	platform_set_drvdata(pdev, atcrtc_dev);


            	reg_base = devm_platform_ioremap_resource(pdev, 0);

            
            	if (IS_ERR(reg_base))

            
            		return dev_err_probe(&pdev->dev, PTR_ERR(reg_base),

            
            				     "Failed to map I/O space\n");


            	atcrtc_dev->regmap = devm_regmap_init_mmio(&pdev->dev,

            
            						   reg_base,

            
            						   &atcrtc_regmap_config);

            
            	if (IS_ERR(atcrtc_dev->regmap))

            
            		return dev_err_probe(&pdev->dev, PTR_ERR(atcrtc_dev->regmap),

            
            				     "Failed to initialize regmap\n");


            	regmap_read(atcrtc_dev->regmap, RTC_ID, &rtc_id);

            
            	if (FIELD_GET(ID_MSK, rtc_id) != ID_ATCRTC100)

            
            		return dev_err_probe(&pdev->dev, -ENODEV,

            
            				     "Failed to initialize RTC: unsupported hardware ID 0x%x\n",

            
            				     rtc_id);


            	ret = platform_get_irq(pdev, 1);

            
            	if (ret < 0)

            
            		return dev_err_probe(&pdev->dev, ret,

            
            				     "Failed to get IRQ for alarm\n");

            
            	atcrtc_dev->alarm_irq = ret;


            	ret = devm_request_irq(&pdev->dev,

            
            			       atcrtc_dev->alarm_irq,

            
            			       atcrtc_alarm_isr,

            
            			       0,

            
            			       "atcrtc_alarm",

            
            			       atcrtc_dev);

            
            	if (ret)

            
            		return dev_err_probe(&pdev->dev, ret,

            
            				     "Failed to request IRQ %d for alarm\n",

            
            				     atcrtc_dev->alarm_irq);


            	atcrtc_dev->rtc_dev = devm_rtc_allocate_device(&pdev->dev);

            
            	if (IS_ERR(atcrtc_dev->rtc_dev))

            
            		return dev_err_probe(&pdev->dev, PTR_ERR(atcrtc_dev->rtc_dev),

            
            				     "Failed to allocate RTC device\n");


            	set_bit(RTC_FEATURE_ALARM, atcrtc_dev->rtc_dev->features);

            
            	ret = device_init_wakeup(&pdev->dev, true);

            
            	if (ret)

            
            		return dev_err_probe(&pdev->dev, ret,

            
            				     "Failed to initialize wake capability\n");


            	ret = dev_pm_set_wake_irq(&pdev->dev, atcrtc_dev->alarm_irq);

            
            	if (ret) {

            
            		device_init_wakeup(&pdev->dev, false);

            
            		return dev_err_probe(&pdev->dev, ret,

            
            				     "Failed to set wake IRQ\n");

            
            	}


            	atcrtc_dev->rtc_dev->ops = &rtc_ops;


            	INIT_WORK(&atcrtc_dev->rtc_work, atcrtc_alarm_clear);

            
            	return devm_rtc_register_device(atcrtc_dev->rtc_dev);

            
            }


            static int atcrtc_resume(struct device *dev)

            
            {

            
            	struct atcrtc_dev *rtc = dev_get_drvdata(dev);


            	if (device_may_wakeup(dev))

            
            		disable_irq_wake(rtc->alarm_irq);


            	return 0;

            
            }


            static int atcrtc_suspend(struct device *dev)

            
            {

            
            	struct atcrtc_dev *rtc = dev_get_drvdata(dev);


            	if (device_may_wakeup(dev))

            
            		enable_irq_wake(rtc->alarm_irq);


            	return 0;

            
            }


            static DEFINE_SIMPLE_DEV_PM_OPS(atcrtc_pm_ops, atcrtc_suspend, atcrtc_resume);


            static const struct of_device_id atcrtc_dt_match[] = {

            
            	{ .compatible = "andestech,atcrtc100" },

            
            	{ },

            
            };

            
            MODULE_DEVICE_TABLE(of, atcrtc_dt_match);


            static struct platform_driver atcrtc_platform_driver = {

            
            	.driver = {

            
            		.name = "atcrtc100",

            
            		.of_match_table = atcrtc_dt_match,

            
            		.pm = pm_sleep_ptr(&atcrtc_pm_ops),

            
            	},

            
            	.probe = atcrtc_probe,

            
            };


            module_platform_driver(atcrtc_platform_driver);


            MODULE_AUTHOR("CL Wang <cl634@andestech.com>");

            
            MODULE_DESCRIPTION("Andes ATCRTC100 driver");

            
            MODULE_LICENSE("GPL");
	// SPDX-License-Identifier: GPL-2.0-or-later
	/*
	* Driver for Andes ATCRTC100 real time clock.
	*
	* Copyright (C) 2025 Andes Technology Corporation
	*/

	#include <linux/bitfield.h>
	#include <linux/delay.h>
	#include <linux/interrupt.h>
	#include <linux/math64.h>
	#include <linux/module.h>
	#include <linux/of.h>
	#include <linux/platform_device.h>
	#include <linux/pm_wakeirq.h>
	#include <linux/regmap.h>
	#include <linux/rtc.h>
	#include <linux/workqueue.h>

	/* Register Offsets */
	#define RTC_ID 0x00 /* ID and Revision Register */
	#define RTC_RSV 0x04 /* Reserved Register */
	#define RTC_CNT 0x10 /* Counter Register */
	#define RTC_ALM 0x14 /* Alarm Register */
	#define RTC_CR 0x18 /* Control Register */
	#define RTC_STA 0x1C /* Status Register */
	#define RTC_TRIM 0x20 /* Digital Trimming Register */

	/* RTC_ID Register */
	#define ID_MSK GENMASK(31, 8)
	#define ID_ATCRTC100 0x030110

	/* RTC_CNT and RTC_ALM Register Fields */
	#define SEC_MSK GENMASK(5, 0)
	#define MIN_MSK GENMASK(11, 6)
	#define HOUR_MSK GENMASK(16, 12)
	#define DAY_MSK GENMASK(31, 17)
	#define RTC_SEC_GET(x) FIELD_GET(SEC_MSK, x)
	#define RTC_MIN_GET(x) FIELD_GET(MIN_MSK, x)
	#define RTC_HOUR_GET(x) FIELD_GET(HOUR_MSK, x)
	#define RTC_DAY_GET(x) FIELD_GET(DAY_MSK, x)
	#define RTC_SEC_SET(x) FIELD_PREP(SEC_MSK, x)
	#define RTC_MIN_SET(x) FIELD_PREP(MIN_MSK, x)
	#define RTC_HOUR_SET(x) FIELD_PREP(HOUR_MSK, x)
	#define RTC_DAY_SET(x) FIELD_PREP(DAY_MSK, x)

	/* RTC_CR Register Bits */
	#define RTC_EN BIT(0) /* RTC Enable */
	#define ALARM_WAKEUP BIT(1) /* Alarm Wakeup Enable */
	#define ALARM_INT BIT(2) /* Alarm Interrupt Enable */
	#define DAY_INT BIT(3) /* Day Interrupt Enable */
	#define HOUR_INT BIT(4) /* Hour Interrupt Enable */
	#define MIN_INT BIT(5) /* Minute Interrupt Enable */
	#define SEC_INT BIT(6) /* Second Periodic Interrupt Enable */
	#define HSEC_INT BIT(7) /* Half-Second Periodic Interrupt Enable */

	/* RTC_STA Register Bits */
	#define WRITE_DONE BIT(16) /* Register write completion status */

	/* Time conversion macro */
	#define ATCRTC_TIME_TO_SEC(D, H, M, S) \
	((time64_t)(D) * 86400 + (H) * 3600 + (M) * 60 + (S))

	/* Timeout for waiting for the write_done bit */
	#define ATCRTC_TIMEOUT_US 1000000
	#define ATCRTC_TIMEOUT_USLEEP_MIN 20
	#define ATCRTC_TIMEOUT_USLEEP_MAX 30

	struct atcrtc_dev {
	struct rtc_device *rtc_dev;
	struct regmap *regmap;
	struct work_struct rtc_work;
	unsigned int alarm_irq;
	bool alarm_en;
	};

	static const struct regmap_config atcrtc_regmap_config = {
	.reg_bits = 32,
	.reg_stride = 4,
	.val_bits = 32,
	.max_register = RTC_TRIM,
	.cache_type = REGCACHE_NONE,
	};

	/**
	* atcrtc_check_write_done - Wait for RTC registers to be synchronized.
	* @rtc: Pointer to the atcrtc_dev structure.
	*
	* The WriteDone bit in the status register indicates the synchronization
	* progress of RTC register updates. This bit is cleared to zero whenever
	* any RTC control register (Counter, Alarm, Control, etc.) is written.
	* It returns to one only after all previous updates have been fully
	* synchronized to the RTC clock domain. This function polls the WriteDone
	* bit with a timeout to ensure the device is ready for the next operation.
	*
	* Return: 0 on success, or -EBUSY on timeout.
	*/
	static int atcrtc_check_write_done(struct atcrtc_dev *rtc)
	{
	unsigned int val;

	/*
	* Using read_poll_timeout is more efficient than a manual loop
	* with usleep_range.
	*/
	return regmap_read_poll_timeout(rtc->regmap, RTC_STA, val,
	val & WRITE_DONE,
	ATCRTC_TIMEOUT_USLEEP_MIN,
	ATCRTC_TIMEOUT_US);
	}

	static irqreturn_t atcrtc_alarm_isr(int irq, void *dev)
	{
	struct atcrtc_dev *rtc = dev;
	unsigned int status;

	regmap_read(rtc->regmap, RTC_STA, &status);
	if (status & ALARM_INT) {
	regmap_write(rtc->regmap, RTC_STA, ALARM_INT);
	rtc->alarm_en = false;
	schedule_work(&rtc->rtc_work);
	rtc_update_irq(rtc->rtc_dev, 1, RTC_AF \| RTC_IRQF);
	return IRQ_HANDLED;
	}
	return IRQ_NONE;
	}

	static int atcrtc_alarm_irq_enable(struct device *dev, unsigned int enable)
	{
	struct atcrtc_dev *rtc = dev_get_drvdata(dev);
	unsigned int mask;
	int ret;

	ret = atcrtc_check_write_done(rtc);
	if (ret)
	return ret;

	mask = ALARM_WAKEUP \| ALARM_INT;
	regmap_update_bits(rtc->regmap, RTC_CR, mask, enable ? mask : 0);

	return 0;
	}

	static void atcrtc_alarm_clear(struct work_struct *work)
	{
	struct atcrtc_dev *rtc =
	container_of(work, struct atcrtc_dev, rtc_work);
	int ret;

	rtc_lock(rtc->rtc_dev);

	if (!rtc->alarm_en) {
	ret = atcrtc_check_write_done(rtc);
	if (ret)
	dev_info(&rtc->rtc_dev->dev,
	"failed to sync before clearing alarm: %d\n",
	ret);
	else
	regmap_update_bits(rtc->regmap, RTC_CR,
	ALARM_WAKEUP \| ALARM_INT, 0);
	}
	rtc_unlock(rtc->rtc_dev);
	}

	static int atcrtc_read_time(struct device dev, struct rtc_time tm)
	{
	struct atcrtc_dev *rtc = dev_get_drvdata(dev);
	time64_t time;
	unsigned int rtc_cnt;

	if (!regmap_test_bits(rtc->regmap, RTC_CR, RTC_EN))
	return -EIO;

	regmap_read(rtc->regmap, RTC_CNT, &rtc_cnt);
	time = ATCRTC_TIME_TO_SEC(RTC_DAY_GET(rtc_cnt),
	RTC_HOUR_GET(rtc_cnt),
	RTC_MIN_GET(rtc_cnt),
	RTC_SEC_GET(rtc_cnt));
	rtc_time64_to_tm(time, tm);

	return 0;
	}

	static int atcrtc_set_time(struct device dev, struct rtc_time tm)
	{
	struct atcrtc_dev *rtc = dev_get_drvdata(dev);
	time64_t time;
	unsigned int counter;
	unsigned int day;
	int ret;

	time = rtc_tm_to_time64(tm);
	day = div_s64(time, 86400);
	counter = RTC_DAY_SET(day) \|
	RTC_HOUR_SET(tm->tm_hour) \|
	RTC_MIN_SET(tm->tm_min) \|
	RTC_SEC_SET(tm->tm_sec);
	ret = atcrtc_check_write_done(rtc);
	if (ret)
	return ret;
	regmap_write(rtc->regmap, RTC_CNT, counter);

	ret = atcrtc_check_write_done(rtc);
	if (ret)
	return ret;
	regmap_update_bits(rtc->regmap, RTC_CR, RTC_EN, RTC_EN);

	return 0;
	}

	static int atcrtc_read_alarm(struct device dev, struct rtc_wkalrm wkalrm)
	{
	struct atcrtc_dev *rtc = dev_get_drvdata(dev);
	struct rtc_time *tm = &wkalrm->time;
	unsigned int rtc_alarm;

	wkalrm->enabled = regmap_test_bits(rtc->regmap, RTC_CR, ALARM_INT);
	regmap_read(rtc->regmap, RTC_ALM, &rtc_alarm);
	tm->tm_hour = RTC_HOUR_GET(rtc_alarm);
	tm->tm_min = RTC_MIN_GET(rtc_alarm);
	tm->tm_sec = RTC_SEC_GET(rtc_alarm);

	/* The RTC alarm does not support day/month/year fields */
	tm->tm_mday = -1;
	tm->tm_mon = -1;
	tm->tm_year = -1;

	return 0;
	}

	static int atcrtc_set_alarm(struct device dev, struct rtc_wkalrm wkalrm)
	{
	struct atcrtc_dev *rtc = dev_get_drvdata(dev);
	struct rtc_time *tm = &wkalrm->time;
	unsigned int rtc_alarm;
	int ret;

	/* Disable alarm first before setting a new one */
	ret = atcrtc_alarm_irq_enable(dev, 0);
	if (ret)
	return ret;

	rtc->alarm_en = false;

	rtc_alarm = RTC_SEC_SET(tm->tm_sec) \|
	RTC_MIN_SET(tm->tm_min) \|
	RTC_HOUR_SET(tm->tm_hour);

	ret = atcrtc_check_write_done(rtc);
	if (ret)
	return ret;

	regmap_write(rtc->regmap, RTC_ALM, rtc_alarm);

	rtc->alarm_en = wkalrm->enabled;
	ret = atcrtc_alarm_irq_enable(dev, wkalrm->enabled);

	return ret;
	}

	static const struct rtc_class_ops rtc_ops = {
	.read_time = atcrtc_read_time,
	.set_time = atcrtc_set_time,
	.read_alarm = atcrtc_read_alarm,
	.set_alarm = atcrtc_set_alarm,
	.alarm_irq_enable = atcrtc_alarm_irq_enable,
	};

	static int atcrtc_probe(struct platform_device *pdev)
	{
	struct atcrtc_dev *atcrtc_dev;
	void __iomem *reg_base;
	unsigned int rtc_id;
	int ret;

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

	reg_base = devm_platform_ioremap_resource(pdev, 0);
	if (IS_ERR(reg_base))
	return dev_err_probe(&pdev->dev, PTR_ERR(reg_base),
	"Failed to map I/O space\n");

	atcrtc_dev->regmap = devm_regmap_init_mmio(&pdev->dev,
	reg_base,
	&atcrtc_regmap_config);
	if (IS_ERR(atcrtc_dev->regmap))
	return dev_err_probe(&pdev->dev, PTR_ERR(atcrtc_dev->regmap),
	"Failed to initialize regmap\n");

	regmap_read(atcrtc_dev->regmap, RTC_ID, &rtc_id);
	if (FIELD_GET(ID_MSK, rtc_id) != ID_ATCRTC100)
	return dev_err_probe(&pdev->dev, -ENODEV,
	"Failed to initialize RTC: unsupported hardware ID 0x%x\n",
	rtc_id);

	ret = platform_get_irq(pdev, 1);
	if (ret < 0)
	return dev_err_probe(&pdev->dev, ret,
	"Failed to get IRQ for alarm\n");
	atcrtc_dev->alarm_irq = ret;

	ret = devm_request_irq(&pdev->dev,
	atcrtc_dev->alarm_irq,
	atcrtc_alarm_isr,
	0,
	"atcrtc_alarm",
	atcrtc_dev);
	if (ret)
	return dev_err_probe(&pdev->dev, ret,
	"Failed to request IRQ %d for alarm\n",
	atcrtc_dev->alarm_irq);

	atcrtc_dev->rtc_dev = devm_rtc_allocate_device(&pdev->dev);
	if (IS_ERR(atcrtc_dev->rtc_dev))
	return dev_err_probe(&pdev->dev, PTR_ERR(atcrtc_dev->rtc_dev),
	"Failed to allocate RTC device\n");

	set_bit(RTC_FEATURE_ALARM, atcrtc_dev->rtc_dev->features);
	ret = device_init_wakeup(&pdev->dev, true);
	if (ret)
	return dev_err_probe(&pdev->dev, ret,
	"Failed to initialize wake capability\n");

	ret = dev_pm_set_wake_irq(&pdev->dev, atcrtc_dev->alarm_irq);
	if (ret) {
	device_init_wakeup(&pdev->dev, false);
	return dev_err_probe(&pdev->dev, ret,
	"Failed to set wake IRQ\n");
	}

	atcrtc_dev->rtc_dev->ops = &rtc_ops;

	INIT_WORK(&atcrtc_dev->rtc_work, atcrtc_alarm_clear);
	return devm_rtc_register_device(atcrtc_dev->rtc_dev);
	}

	static int atcrtc_resume(struct device *dev)
	{
	struct atcrtc_dev *rtc = dev_get_drvdata(dev);

	if (device_may_wakeup(dev))
	disable_irq_wake(rtc->alarm_irq);

	return 0;
	}

	static int atcrtc_suspend(struct device *dev)
	{
	struct atcrtc_dev *rtc = dev_get_drvdata(dev);

	if (device_may_wakeup(dev))
	enable_irq_wake(rtc->alarm_irq);

	return 0;
	}

	static DEFINE_SIMPLE_DEV_PM_OPS(atcrtc_pm_ops, atcrtc_suspend, atcrtc_resume);

	static const struct of_device_id atcrtc_dt_match[] = {
	{ .compatible = "andestech,atcrtc100" },
	{ },
	};
	MODULE_DEVICE_TABLE(of, atcrtc_dt_match);

	static struct platform_driver atcrtc_platform_driver = {
	.driver = {
	.name = "atcrtc100",
	.of_match_table = atcrtc_dt_match,
	.pm = pm_sleep_ptr(&atcrtc_pm_ops),
	},
	.probe = atcrtc_probe,
	};

	module_platform_driver(atcrtc_platform_driver);

	MODULE_AUTHOR("CL Wang <cl634@andestech.com>");
	MODULE_DESCRIPTION("Andes ATCRTC100 driver");
	MODULE_LICENSE("GPL");