drivers/rtc/rtc-hi6421.c - arm/linux-arm-legacy - Git at Google

 /*
  * Hisilicon Hi6421 RTC driver
  *
  * Copyright (C) 2013 Hisilicon Ltd.
  * Copyright (C) 2013 Linaro Ltd.
  *
  * Author: Haojian Zhuang <haojian.zhuang@linaro.org>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */


 #include <linux/module.h>
 #include <linux/platform_device.h>
 #include <linux/err.h>
 #include <linux/io.h>
 #include <linux/of_device.h>
 #include <linux/rtc.h>
 #include <linux/mfd/hi6421-pmic.h>

 #define	REG_IRQ1			0x01
 #define	REG_IRQM1			0x04
 #define	REG_RTCDR0			0x58
 #define	REG_RTCDR1			0x59
 #define	REG_RTCDR2			0x5a
 #define	REG_RTCDR3			0x5b
 #define	REG_RTCMR0			0x5c
 #define	REG_RTCMR1			0x5d
 #define	REG_RTCMR2			0x5e
 #define	REG_RTCMR3			0x5f
 #define	REG_RTCLR0			0x60
 #define	REG_RTCLR1			0x61
 #define	REG_RTCLR2			0x62
 #define	REG_RTCLR3			0x63
 #define	REG_RTCCTRL			0x64
 #define REG_SOFT_RST			0x86

 #define ALARM_ON			(1 << HI6421_IRQ_ALARM)

 struct hi6421_rtc_info {
 	struct rtc_device	*rtc;
 	struct hi6421_pmic	*pmic;
 	int			irq;
 };

 static irqreturn_t hi6421_rtc_handler(int irq, void *data)
 {
 	struct hi6421_rtc_info *info = (struct hi6421_rtc_info *)data;

 	/* clear alarm status */
 	hi6421_pmic_rmw(info->pmic, REG_IRQ1, ALARM_ON, ALARM_ON);
 	rtc_update_irq(info->rtc, 1, RTC_AF);
 	return IRQ_HANDLED;
 }

 /* read 4 8-bit registers & covert it into a 32-bit data */
 static unsigned int hi6421_read_bulk(struct hi6421_pmic *pmic,
 				     unsigned int addr)
 {
 	unsigned int data, sum = 0;
 	int i;

 	for (i = 0; i < 4; i++) {
 		data = hi6421_pmic_read(pmic, addr + i);
 		sum |= (data & 0xff) << (i * 8);
 	}
 	return sum;
 }

 /* write a 32-bit data into 4 8-bit registers */
 static void hi6421_write_bulk(struct hi6421_pmic *pmic, unsigned int addr,
 			      unsigned int data)
 {
 	unsigned int value;
 	int i;

 	for (i = 0; i < 4; i++) {
 		value = (data >> (i * 8)) & 0xff;
 		hi6421_pmic_write(pmic, addr + i, value);
 	}
 }

 static int hi6421_rtc_read_time(struct device *dev, struct rtc_time *tm)
 {
 	struct hi6421_rtc_info *info = dev_get_drvdata(dev);
 	unsigned long ticks;

 	ticks = hi6421_read_bulk(info->pmic, REG_RTCDR0);
 	rtc_time_to_tm(ticks, tm);
 	return 0;
 }

 static int hi6421_rtc_set_time(struct device *dev, struct rtc_time *tm)
 {
 	struct hi6421_rtc_info *info = dev_get_drvdata(dev);
 	unsigned long ticks;

 	if ((tm->tm_year < 70) || (tm->tm_year > 138)) {
 		dev_dbg(dev, "Set time %d out of range. "
 			"Please set time between 1970 to 2038.\n",
 			1900 + tm->tm_year);
 		return -EINVAL;
 	}
 	rtc_tm_to_time(tm, &ticks);
 	hi6421_write_bulk(info->pmic, REG_RTCLR0, ticks);
 	return 0;
 }

 static int hi6421_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
 {
 	struct hi6421_rtc_info *info = dev_get_drvdata(dev);
 	unsigned long ticks, data;

 	ticks = hi6421_read_bulk(info->pmic, REG_RTCMR0);
 	rtc_time_to_tm(ticks, &alrm->time);

 	data = hi6421_pmic_read(info->pmic, REG_IRQ1);
 	alrm->pending = (data & ALARM_ON) ? 1 : 0;

 	data = hi6421_pmic_read(info->pmic, REG_IRQM1);
 	alrm->enabled = (data & ALARM_ON) ? 0 : 1;
 	return 0;
 }

 /*
  * Calculate the next alarm time given the requested alarm time mask
  * and the current time.
  */
 static void rtc_next_alarm_time(struct rtc_time *next, struct rtc_time *now,
 				struct rtc_time *alrm)
 {
 	unsigned long next_time;
 	unsigned long now_time;

 	next->tm_year = now->tm_year;
 	next->tm_mon = now->tm_mon;
 	next->tm_mday = now->tm_mday;
 	next->tm_hour = alrm->tm_hour;
 	next->tm_min = alrm->tm_min;
 	next->tm_sec = alrm->tm_sec;

 	rtc_tm_to_time(now, &now_time);
 	rtc_tm_to_time(next, &next_time);

 	if (next_time < now_time) {
 		/* Advance one day */
 		next_time += 60 * 60 * 24;
 		rtc_time_to_tm(next_time, next);
 	}
 }

 static int hi6421_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
 {
 	struct hi6421_rtc_info *info = dev_get_drvdata(dev);
 	struct rtc_time now_tm, alarm_tm;
 	unsigned long ticks;

 	/* load 32-bit read-only counter */
 	ticks = hi6421_read_bulk(info->pmic, REG_RTCDR0);
 	rtc_time_to_tm(ticks, &now_tm);
 	dev_dbg(dev, "%s, now time : %lu\n", __func__, ticks);
 	rtc_next_alarm_time(&alarm_tm, &now_tm, &alrm->time);

 	/* get new ticks for alarm in 24 hours */
 	rtc_tm_to_time(&alarm_tm, &ticks);
 	dev_dbg(dev, "%s, alarm time: %lu\n", __func__, ticks);
 	if (alrm->enabled)
 		hi6421_write_bulk(info->pmic, REG_RTCMR0, ticks);
 	return 0;
 }

 static int hi6421_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
 {
 	struct hi6421_rtc_info *info = dev_get_drvdata(dev);
 	unsigned int data = 0;

 	if (!enabled)
 		data = ALARM_ON;
 	hi6421_pmic_rmw(info->pmic, REG_IRQM1, ALARM_ON, data);
 	return 0;
 }

 static const struct rtc_class_ops hi6421_rtc_ops = {
 	.read_time	= hi6421_rtc_read_time,
 	.set_time	= hi6421_rtc_set_time,
 	.read_alarm	= hi6421_rtc_read_alarm,
 	.set_alarm	= hi6421_rtc_set_alarm,
 	.alarm_irq_enable = hi6421_rtc_alarm_irq_enable,
 };

 static int hi6421_rtc_probe(struct platform_device *pdev)
 {
 	struct hi6421_rtc_info *info;
 	int ret;

 	info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
 	if (!info) {
 		dev_err(&pdev->dev, "failed to allocate memory\n");
 		return -ENOMEM;
 	}
 	info->irq = platform_get_irq(pdev, 0);
 	if (info->irq < 0)
 		return -ENOENT;

 	info->pmic = dev_get_drvdata(pdev->dev.parent);
 	platform_set_drvdata(pdev, info);

 	/* enable RTC device */
 	hi6421_pmic_write(info->pmic, REG_RTCCTRL, 1);

 	info->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
 					&hi6421_rtc_ops, THIS_MODULE);
 	if (IS_ERR(info->rtc))
 		return PTR_ERR(info->rtc);

 	ret = devm_request_irq(&pdev->dev, info->irq, hi6421_rtc_handler,
 			       IRQF_DISABLED, "alarm", info);
 	if (ret < 0)
 		return ret;

 	return 0;
 }

 static int hi6421_rtc_remove(struct platform_device *pdev)
 {
 	return 0;
 }

 static struct of_device_id hi6421_rtc_of_match[] = {
 	{ .compatible = "hisilicon,hi6421-rtc" },
 	{ }
 };
 MODULE_DEVICE_TABLE(of, hi6421_rtc_of_match);

 static struct platform_driver hi6421_rtc_driver = {
 	.driver = {
 		.name = "hi6421-rtc",
 		.of_match_table = of_match_ptr(hi6421_rtc_of_match),
 	},
 	.probe = hi6421_rtc_probe,
 	.remove = hi6421_rtc_remove,
 };
 module_platform_driver(hi6421_rtc_driver);

 MODULE_LICENSE("GPLv2");
 MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@linaro.org");
 MODULE_ALIAS("platform:hi6421-rtc");
	/*
	* Hisilicon Hi6421 RTC driver
	*
	* Copyright (C) 2013 Hisilicon Ltd.
	* Copyright (C) 2013 Linaro Ltd.
	*
	* Author: Haojian Zhuang <haojian.zhuang@linaro.org>
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation; either version 2 of the License, or
	* (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, write to the Free Software
	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	*/


	#include <linux/module.h>
	#include <linux/platform_device.h>
	#include <linux/err.h>
	#include <linux/io.h>
	#include <linux/of_device.h>
	#include <linux/rtc.h>
	#include <linux/mfd/hi6421-pmic.h>

	#define REG_IRQ1 0x01
	#define REG_IRQM1 0x04
	#define REG_RTCDR0 0x58
	#define REG_RTCDR1 0x59
	#define REG_RTCDR2 0x5a
	#define REG_RTCDR3 0x5b
	#define REG_RTCMR0 0x5c
	#define REG_RTCMR1 0x5d
	#define REG_RTCMR2 0x5e
	#define REG_RTCMR3 0x5f
	#define REG_RTCLR0 0x60
	#define REG_RTCLR1 0x61
	#define REG_RTCLR2 0x62
	#define REG_RTCLR3 0x63
	#define REG_RTCCTRL 0x64
	#define REG_SOFT_RST 0x86

	#define ALARM_ON (1 << HI6421_IRQ_ALARM)

	struct hi6421_rtc_info {
	struct rtc_device *rtc;
	struct hi6421_pmic *pmic;
	int irq;
	};

	static irqreturn_t hi6421_rtc_handler(int irq, void *data)
	{
	struct hi6421_rtc_info info = (struct hi6421_rtc_info )data;

	/* clear alarm status */
	hi6421_pmic_rmw(info->pmic, REG_IRQ1, ALARM_ON, ALARM_ON);
	rtc_update_irq(info->rtc, 1, RTC_AF);
	return IRQ_HANDLED;
	}

	/* read 4 8-bit registers & covert it into a 32-bit data */
	static unsigned int hi6421_read_bulk(struct hi6421_pmic *pmic,
	unsigned int addr)
	{
	unsigned int data, sum = 0;
	int i;

	for (i = 0; i < 4; i++) {
	data = hi6421_pmic_read(pmic, addr + i);
	sum \|= (data & 0xff) << (i * 8);
	}
	return sum;
	}

	/* write a 32-bit data into 4 8-bit registers */
	static void hi6421_write_bulk(struct hi6421_pmic *pmic, unsigned int addr,
	unsigned int data)
	{
	unsigned int value;
	int i;

	for (i = 0; i < 4; i++) {
	value = (data >> (i * 8)) & 0xff;
	hi6421_pmic_write(pmic, addr + i, value);
	}
	}

	static int hi6421_rtc_read_time(struct device dev, struct rtc_time tm)
	{
	struct hi6421_rtc_info *info = dev_get_drvdata(dev);
	unsigned long ticks;

	ticks = hi6421_read_bulk(info->pmic, REG_RTCDR0);
	rtc_time_to_tm(ticks, tm);
	return 0;
	}

	static int hi6421_rtc_set_time(struct device dev, struct rtc_time tm)
	{
	struct hi6421_rtc_info *info = dev_get_drvdata(dev);
	unsigned long ticks;

	if ((tm->tm_year < 70) \|\| (tm->tm_year > 138)) {
	dev_dbg(dev, "Set time %d out of range. "
	"Please set time between 1970 to 2038.\n",
	1900 + tm->tm_year);
	return -EINVAL;
	}
	rtc_tm_to_time(tm, &ticks);
	hi6421_write_bulk(info->pmic, REG_RTCLR0, ticks);
	return 0;
	}

	static int hi6421_rtc_read_alarm(struct device dev, struct rtc_wkalrm alrm)
	{
	struct hi6421_rtc_info *info = dev_get_drvdata(dev);
	unsigned long ticks, data;

	ticks = hi6421_read_bulk(info->pmic, REG_RTCMR0);
	rtc_time_to_tm(ticks, &alrm->time);

	data = hi6421_pmic_read(info->pmic, REG_IRQ1);
	alrm->pending = (data & ALARM_ON) ? 1 : 0;

	data = hi6421_pmic_read(info->pmic, REG_IRQM1);
	alrm->enabled = (data & ALARM_ON) ? 0 : 1;
	return 0;
	}

	/*
	* Calculate the next alarm time given the requested alarm time mask
	* and the current time.
	*/
	static void rtc_next_alarm_time(struct rtc_time next, struct rtc_time now,
	struct rtc_time *alrm)
	{
	unsigned long next_time;
	unsigned long now_time;

	next->tm_year = now->tm_year;
	next->tm_mon = now->tm_mon;
	next->tm_mday = now->tm_mday;
	next->tm_hour = alrm->tm_hour;
	next->tm_min = alrm->tm_min;
	next->tm_sec = alrm->tm_sec;

	rtc_tm_to_time(now, &now_time);
	rtc_tm_to_time(next, &next_time);

	if (next_time < now_time) {
	/* Advance one day */
	next_time += 60 * 60 * 24;
	rtc_time_to_tm(next_time, next);
	}
	}

	static int hi6421_rtc_set_alarm(struct device dev, struct rtc_wkalrm alrm)
	{
	struct hi6421_rtc_info *info = dev_get_drvdata(dev);
	struct rtc_time now_tm, alarm_tm;
	unsigned long ticks;

	/* load 32-bit read-only counter */
	ticks = hi6421_read_bulk(info->pmic, REG_RTCDR0);
	rtc_time_to_tm(ticks, &now_tm);
	dev_dbg(dev, "%s, now time : %lu\n", __func__, ticks);
	rtc_next_alarm_time(&alarm_tm, &now_tm, &alrm->time);

	/* get new ticks for alarm in 24 hours */
	rtc_tm_to_time(&alarm_tm, &ticks);
	dev_dbg(dev, "%s, alarm time: %lu\n", __func__, ticks);
	if (alrm->enabled)
	hi6421_write_bulk(info->pmic, REG_RTCMR0, ticks);
	return 0;
	}

	static int hi6421_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
	{
	struct hi6421_rtc_info *info = dev_get_drvdata(dev);
	unsigned int data = 0;

	if (!enabled)
	data = ALARM_ON;
	hi6421_pmic_rmw(info->pmic, REG_IRQM1, ALARM_ON, data);
	return 0;
	}

	static const struct rtc_class_ops hi6421_rtc_ops = {
	.read_time = hi6421_rtc_read_time,
	.set_time = hi6421_rtc_set_time,
	.read_alarm = hi6421_rtc_read_alarm,
	.set_alarm = hi6421_rtc_set_alarm,
	.alarm_irq_enable = hi6421_rtc_alarm_irq_enable,
	};

	static int hi6421_rtc_probe(struct platform_device *pdev)
	{
	struct hi6421_rtc_info *info;
	int ret;

	info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
	if (!info) {
	dev_err(&pdev->dev, "failed to allocate memory\n");
	return -ENOMEM;
	}
	info->irq = platform_get_irq(pdev, 0);
	if (info->irq < 0)
	return -ENOENT;

	info->pmic = dev_get_drvdata(pdev->dev.parent);
	platform_set_drvdata(pdev, info);

	/* enable RTC device */
	hi6421_pmic_write(info->pmic, REG_RTCCTRL, 1);

	info->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
	&hi6421_rtc_ops, THIS_MODULE);
	if (IS_ERR(info->rtc))
	return PTR_ERR(info->rtc);

	ret = devm_request_irq(&pdev->dev, info->irq, hi6421_rtc_handler,
	IRQF_DISABLED, "alarm", info);
	if (ret < 0)
	return ret;

	return 0;
	}

	static int hi6421_rtc_remove(struct platform_device *pdev)
	{
	return 0;
	}

	static struct of_device_id hi6421_rtc_of_match[] = {
	{ .compatible = "hisilicon,hi6421-rtc" },
	{ }
	};
	MODULE_DEVICE_TABLE(of, hi6421_rtc_of_match);

	static struct platform_driver hi6421_rtc_driver = {
	.driver = {
	.name = "hi6421-rtc",
	.of_match_table = of_match_ptr(hi6421_rtc_of_match),
	},
	.probe = hi6421_rtc_probe,
	.remove = hi6421_rtc_remove,
	};
	module_platform_driver(hi6421_rtc_driver);

	MODULE_LICENSE("GPLv2");
	MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@linaro.org");
	MODULE_ALIAS("platform:hi6421-rtc");