drivers/rtc/rtc-da9052.c

/*
 * Copyright(c) 2009 Dialog Semiconductor Ltd.
 *
 * 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.
 *
 * rtc-da9052.c: RTC driver for DA9052
 */

#include <linux/platform_device.h>
#include <linux/rtc.h>
#include <linux/mfd/da9052/da9052.h>
#include <linux/mfd/da9052/reg.h>
#include <linux/mfd/da9052/rtc.h>

#define DRIVER_NAME "da9052-rtc"
#define ENABLE		1
#define DISABLE		0

struct da9052_rtc {
	struct rtc_device *rtc;
	struct da9052 *da9052;
	struct da9052_eh_nb eh_data;
	unsigned char is_min_alarm;
	unsigned char enable_tick_alarm;
	unsigned char enable_clk_buffer;
	unsigned char set_osc_trim_freq;
};

static int da9052_rtc_enable_alarm(struct da9052 *da9052, unsigned char flag);

void da9052_rtc_notifier(struct da9052_eh_nb *eh_data, unsigned int event)
{
	struct da9052_rtc *rtc =
		container_of(eh_data, struct da9052_rtc, eh_data);
	struct da9052_ssc_msg msg;
	unsigned int ret;

	/* Check the alarm type - TIMER or TICK */
	msg.addr = DA9052_ALARMMI_REG;

	da9052_lock(rtc->da9052);
	ret = rtc->da9052->read(rtc->da9052, &msg);
	if (ret != 0) {
		da9052_unlock(rtc->da9052);
		return;
	}

	da9052_unlock(rtc->da9052);


	if (msg.data & DA9052_ALARMMI_ALARMTYPE) {
		da9052_rtc_enable_alarm(rtc->da9052, 0);
		printk(KERN_INFO "RTC: TIMER ALARM\n");
	} else {
		kobject_uevent(&rtc->rtc->dev.kobj, KOBJ_CHANGE);
		printk(KERN_INFO "RTC: TICK ALARM\n");
	}
}

static int da9052_rtc_validate_parameters(struct rtc_time *rtc_tm)
{

	if (rtc_tm->tm_sec > DA9052_RTC_SECONDS_LIMIT)
		return DA9052_RTC_INVALID_SECONDS;

	if (rtc_tm->tm_min > DA9052_RTC_MINUTES_LIMIT)
		return DA9052_RTC_INVALID_MINUTES;

	if (rtc_tm->tm_hour > DA9052_RTC_HOURS_LIMIT)
		return DA9052_RTC_INVALID_HOURS;

	if (rtc_tm->tm_mday == 0)
		return DA9052_RTC_INVALID_DAYS;

	if ((rtc_tm->tm_mon > DA9052_RTC_MONTHS_LIMIT) ||
	(rtc_tm->tm_mon == 0))
		return DA9052_RTC_INVALID_MONTHS;

	if (rtc_tm->tm_year > DA9052_RTC_YEARS_LIMIT)
		return DA9052_RTC_INVALID_YEARS;

	if ((rtc_tm->tm_mon == FEBRUARY)) {
		if (((rtc_tm->tm_year % 4 == 0) &&
			(rtc_tm->tm_year % 100 != 0)) ||
			(rtc_tm->tm_year % 400 == 0)) {
			if (rtc_tm->tm_mday > 29)
				return DA9052_RTC_INVALID_DAYS;
		} else if (rtc_tm->tm_mday > 28) {
			return DA9052_RTC_INVALID_DAYS;
		}
	}

	if (((rtc_tm->tm_mon == APRIL) || (rtc_tm->tm_mon == JUNE) ||
		(rtc_tm->tm_mon == SEPTEMBER) || (rtc_tm->tm_mon == NOVEMBER))
		&& (rtc_tm->tm_mday == 31)) {
		return DA9052_RTC_INVALID_DAYS;
	}


	return 0;
}

static int da9052_rtc_settime(struct da9052 *da9052, struct rtc_time *rtc_tm)
{

	struct da9052_ssc_msg msg_arr[6];
	int validate_param = 0;
	unsigned char loop_index = 0;
	int ret = 0;


	/* System compatability */
	rtc_tm->tm_year -= 100;
	rtc_tm->tm_mon += 1;

	validate_param = da9052_rtc_validate_parameters(rtc_tm);
	if (validate_param)
		return validate_param;

	msg_arr[loop_index].addr = DA9052_COUNTS_REG;
	msg_arr[loop_index++].data = DA9052_COUNTS_MONITOR | rtc_tm->tm_sec;

	msg_arr[loop_index].addr = DA9052_COUNTMI_REG;
	msg_arr[loop_index].data = 0;
	msg_arr[loop_index++].data = rtc_tm->tm_min;

	msg_arr[loop_index].addr = DA9052_COUNTH_REG;
	msg_arr[loop_index].data = 0;
	msg_arr[loop_index++].data = rtc_tm->tm_hour;

	msg_arr[loop_index].addr = DA9052_COUNTD_REG;
	msg_arr[loop_index].data = 0;
	msg_arr[loop_index++].data = rtc_tm->tm_mday;

	msg_arr[loop_index].addr = DA9052_COUNTMO_REG;
	msg_arr[loop_index].data = 0;
	msg_arr[loop_index++].data = rtc_tm->tm_mon;

	msg_arr[loop_index].addr = DA9052_COUNTY_REG;
	msg_arr[loop_index].data = 0;
	msg_arr[loop_index++].data = rtc_tm->tm_year;

	da9052_lock(da9052);
	ret = da9052->write_many(da9052, msg_arr, loop_index);
	if (ret != 0) {
		da9052_unlock(da9052);
		return ret;
	}

	da9052_unlock(da9052);
	return 0;
}

static int da9052_rtc_gettime(struct da9052 *da9052, struct rtc_time *rtc_tm)
{

	struct da9052_ssc_msg msg[6];
	unsigned char loop_index = 0;
	int validate_param = 0;
	int ret = 0;

	msg[loop_index].data = 0;
	msg[loop_index++].addr = DA9052_COUNTS_REG;

	msg[loop_index].data = 0;
	msg[loop_index++].addr = DA9052_COUNTMI_REG;

	msg[loop_index].data = 0;
	msg[loop_index++].addr = DA9052_COUNTH_REG;

	msg[loop_index].data = 0;
	msg[loop_index++].addr = DA9052_COUNTD_REG;

	msg[loop_index].data = 0;
	msg[loop_index++].addr = DA9052_COUNTMO_REG;

	msg[loop_index].data = 0;
	msg[loop_index++].addr = DA9052_COUNTY_REG;

	da9052_lock(da9052);
	ret = da9052->read_many(da9052, msg, loop_index);
	if (ret != 0) {
		da9052_unlock(da9052);
		return ret;
	}
	da9052_unlock(da9052);

	rtc_tm->tm_year = msg[--loop_index].data & DA9052_COUNTY_COUNTYEAR;
	rtc_tm->tm_mon = msg[--loop_index].data & DA9052_COUNTMO_COUNTMONTH;
	rtc_tm->tm_mday = msg[--loop_index].data & DA9052_COUNTD_COUNTDAY;
	rtc_tm->tm_hour = msg[--loop_index].data & DA9052_COUNTH_COUNTHOUR;
	rtc_tm->tm_min = msg[--loop_index].data & DA9052_COUNTMI_COUNTMIN;
	rtc_tm->tm_sec = msg[--loop_index].data & DA9052_COUNTS_COUNTSEC;

	validate_param = da9052_rtc_validate_parameters(rtc_tm);
	if (validate_param)
		return validate_param;

	/* System compatability */
	rtc_tm->tm_year += 100;
	rtc_tm->tm_mon -= 1;
	return 0;
}

static int da9052_alarm_gettime(struct da9052 *da9052, struct rtc_time *rtc_tm)
{
	struct da9052_ssc_msg msg[5];
	unsigned char loop_index = 0;
	int validate_param = 0;
	int ret = 0;

	msg[loop_index].data = 0;
	msg[loop_index++].addr = DA9052_ALARMMI_REG;

	msg[loop_index].data = 0;
	msg[loop_index++].addr = DA9052_ALARMH_REG;

	msg[loop_index].data = 0;
	msg[loop_index++].addr = DA9052_ALARMD_REG;

	msg[loop_index].data = 0;
	msg[loop_index++].addr = DA9052_ALARMMO_REG;

	msg[loop_index].data = 0;
	msg[loop_index++].addr = DA9052_ALARMY_REG;

	da9052_lock(da9052);
	ret = da9052->read_many(da9052, msg, loop_index);
	if (ret != 0) {
		da9052_unlock(da9052);
		return ret;
	}
	da9052_unlock(da9052);

	rtc_tm->tm_year = msg[--loop_index].data & DA9052_ALARMY_ALARMYEAR;
	rtc_tm->tm_mon = msg[--loop_index].data & DA9052_ALARMMO_ALARMMONTH;
	rtc_tm->tm_mday = msg[--loop_index].data & DA9052_ALARMD_ALARMDAY;
	rtc_tm->tm_hour = msg[--loop_index].data & DA9052_ALARMH_ALARMHOUR;
	rtc_tm->tm_min = msg[--loop_index].data & DA9052_ALARMMI_ALARMMIN;

	validate_param = da9052_rtc_validate_parameters(rtc_tm);
	if (validate_param)
		return validate_param;

	/* System compatability */
	rtc_tm->tm_year += 100;
	rtc_tm->tm_mon -= 1;

	return 0;
}

static int da9052_alarm_settime(struct da9052 *da9052, struct rtc_time *rtc_tm)
{

	struct da9052_ssc_msg msg_arr[5];
	struct da9052_ssc_msg msg;
	int validate_param = 0;
	unsigned char loop_index = 0;
	int ret = 0;

	rtc_tm->tm_sec = 0;

	/* System compatability */
	rtc_tm->tm_year -= 100;
	rtc_tm->tm_mon += 1;

	validate_param = da9052_rtc_validate_parameters(rtc_tm);
	if (validate_param)
		return validate_param;

	msg.addr = DA9052_ALARMMI_REG;
	msg.data = 0;

	da9052_lock(da9052);
	ret = da9052->read(da9052, &msg);
	if (ret != 0) {
		da9052_unlock(da9052);
		return ret;
	}

	msg.data = msg.data & ~(DA9052_ALARMMI_ALARMMIN);
	msg.data |= rtc_tm->tm_min;

	msg_arr[loop_index].addr = DA9052_ALARMMI_REG;
	msg_arr[loop_index].data = 0;
	msg_arr[loop_index++].data = msg.data;

	msg_arr[loop_index].addr = DA9052_ALARMH_REG;
	msg_arr[loop_index].data = 0;
	msg_arr[loop_index++].data = rtc_tm->tm_hour;

	msg_arr[loop_index].addr = DA9052_ALARMD_REG;
	msg_arr[loop_index].data = 0;
	msg_arr[loop_index++].data = rtc_tm->tm_mday;

	msg_arr[loop_index].addr = DA9052_ALARMMO_REG;
	msg_arr[loop_index].data = 0;
	msg_arr[loop_index++].data = rtc_tm->tm_mon;

	msg.addr = DA9052_ALARMY_REG;
	msg.data = 0;
	ret = da9052->read(da9052, &msg);
	if (ret != 0) {
		da9052_unlock(da9052);
		return ret;
	}

	msg.data = msg.data & ~(DA9052_ALARMY_ALARMYEAR);


	msg.data |= rtc_tm->tm_year;
	msg_arr[loop_index].addr = DA9052_ALARMY_REG;
	msg_arr[loop_index].data = 0;
	msg_arr[loop_index++].data = msg.data;

	ret = da9052->write_many(da9052, msg_arr, loop_index);
	if (ret) {
		da9052_unlock(da9052);
		return ret;
	}

	da9052_unlock(da9052);
	return 0;
}

static int da9052_rtc_get_alarm_status(struct da9052 *da9052)
{
	struct da9052_ssc_msg msg;
	int ret = 0;

	msg.addr = DA9052_ALARMY_REG;
	msg.data = 0;
	da9052_lock(da9052);
	ret = da9052->read(da9052, &msg);
	if (ret != 0) {
			da9052_unlock(da9052);
	return ret;
	}

	da9052_unlock(da9052);
	msg.data &= DA9052_ALARMY_ALARMON;

	return (msg.data > 0) ? 1 : 0;
}


static int da9052_rtc_enable_alarm(struct da9052 *da9052, unsigned char flag)
{
	struct da9052_ssc_msg msg;
	int ret = 0;

	msg.addr = DA9052_ALARMY_REG;
	da9052_lock(da9052);
	ret = da9052->read(da9052, &msg);
	if (ret != 0) {
		da9052_unlock(da9052);
		return ret;
	}

	if (flag)
		msg.data = msg.data | DA9052_ALARMY_ALARMON;
	else
		msg.data = msg.data & ~(DA9052_ALARMY_ALARMON);

	ret = da9052->write(da9052, &msg);
	if (ret != 0) {
		da9052_unlock(da9052);
		return ret;
	}
	da9052_unlock(da9052);

	return 0;
}


static ssize_t da9052_rtc_mask_irq(struct da9052 *da9052)
 {
	unsigned char data = 0;
	ssize_t ret = 0;
	struct da9052_ssc_msg ssc_msg;

	ssc_msg.addr = DA9052_IRQMASKA_REG;
	ssc_msg.data = 0;

	da9052_lock(da9052);
	ret = da9052->read(da9052, &ssc_msg);
	if (ret != 0) {
		da9052_unlock(da9052);
		return ret;
	}

	data = ret;
	ssc_msg.data = data |= DA9052_IRQMASKA_MALRAM;

	ret = da9052->write(da9052, &ssc_msg);
	if (ret != 0) {
		da9052_unlock(da9052);
		return ret;
	}

	da9052_unlock(da9052);
	return 0;
}


static ssize_t da9052_rtc_unmask_irq(struct da9052 *da9052)
{
	unsigned char data = 0;
	ssize_t ret = 0;
	struct da9052_ssc_msg ssc_msg;

	ssc_msg.addr =  DA9052_IRQMASKA_REG;
	ssc_msg.data =  0;

	da9052_lock(da9052);
	ret = da9052->read(da9052, &ssc_msg);
	if (ret != 0) {
		da9052_unlock(da9052);
		return ret;
	}

	data = ret;
	ssc_msg.data = data &= ~DA9052_IRQMASKA_MALRAM;

	ret = da9052->write(da9052, &ssc_msg);
	if (ret != 0) {
		da9052_unlock(da9052);
		return ret;
	}

	da9052_unlock(da9052);
	return 0;

}

static int da9052_rtc_class_ops_gettime
			(struct device *dev, struct rtc_time *rtc_tm)
{
	int ret;
	struct da9052 *da9052 = dev_get_drvdata(dev->parent);
	ret = da9052_rtc_gettime(da9052, rtc_tm);
	if (ret)
		return ret;
	return 0;
}


static int da9052_rtc_class_ops_settime(struct device *dev, struct rtc_time *tm)
{
	int ret;
	struct da9052 *da9052 = dev_get_drvdata(dev->parent);
	ret = da9052_rtc_settime(da9052, tm);

	return ret;
}

static int da9052_rtc_readalarm(struct device *dev, struct rtc_wkalrm *alrm)
{
	int ret;
	struct rtc_time *tm = &alrm->time;
	struct da9052 *da9052 = dev_get_drvdata(dev->parent);
	ret = da9052_alarm_gettime(da9052, tm);

	if (ret)
		return ret;

	alrm->enabled = da9052_rtc_get_alarm_status(da9052);

	return 0;

}

static int da9052_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm)
{
	int ret = 0;
	struct rtc_time *tm = &alrm->time;
	struct da9052 *da9052 = dev_get_drvdata(dev->parent);

	ret = da9052_alarm_settime(da9052, tm);

	if (ret)
		return ret;

	ret = da9052_rtc_enable_alarm(da9052, 1);

	return ret;
}

static int da9052_rtc_update_irq_enable(struct device *dev,
		unsigned int enabled)
{
	struct da9052_rtc *priv = dev_get_drvdata(dev);
	int ret = -ENODATA;

	da9052_lock(priv->da9052);

	ret = (enabled ? da9052_rtc_unmask_irq : da9052_rtc_mask_irq)
						(priv->da9052);

	da9052_unlock(priv->da9052);

	return ret;
}

static int da9052_rtc_alarm_irq_enable(struct device *dev,
			unsigned int enabled)
{
	struct da9052_rtc *priv = dev_get_drvdata(dev);

	if (enabled)
		return da9052_rtc_enable_alarm(priv->da9052, enabled);
	else
		return da9052_rtc_enable_alarm(priv->da9052, enabled);
}

static const struct rtc_class_ops da9052_rtc_ops = {
	.read_time	= da9052_rtc_class_ops_gettime,
	.set_time	= da9052_rtc_class_ops_settime,
	.read_alarm	= da9052_rtc_readalarm,
	.set_alarm	= da9052_rtc_setalarm,
#if 0
	.update_irq_enable = da9052_rtc_update_irq_enable,
	.alarm_irq_enable = da9052_rtc_alarm_irq_enable,
#endif
};


static int __devinit da9052_rtc_probe(struct platform_device *pdev)
{
	int ret;
	struct da9052_rtc *priv;
	struct da9052_ssc_msg ssc_msg;
	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
	if (!priv)
		return -ENOMEM;

	priv->da9052 = dev_get_drvdata(pdev->dev.parent);
	platform_set_drvdata(pdev, priv);

	/* Added to support sysfs wakealarm attribute */
	pdev->dev.power.can_wakeup = 1;
	/* Added to support sysfs wakealarm attribute */

	/* Set the EH structure */
	priv->eh_data.eve_type = ALARM_EVE;
	priv->eh_data.call_back = &da9052_rtc_notifier;
	ret = priv->da9052->register_event_notifier(priv->da9052,
		&priv->eh_data);
	if (ret)
		goto err_register_alarm;

	priv->is_min_alarm = 1;
	priv->enable_tick_alarm = 1;
	priv->enable_clk_buffer = 1;
	priv->set_osc_trim_freq = 5;
	/* Enable/Disable TICK Alarm */
	/* Read ALARM YEAR register */
	ssc_msg.addr = DA9052_ALARMY_REG;
	ssc_msg.data = 0;

	da9052_lock(priv->da9052);
	ret = priv->da9052->read(priv->da9052, &ssc_msg);
	if (ret != 0) {
		da9052_unlock(priv->da9052);
		goto err_ssc_comm;
	}

	if (priv->enable_tick_alarm)
		ssc_msg.data = (ssc_msg.data | DA9052_ALARMY_TICKON);
	else
		ssc_msg.data =
		((ssc_msg.data & ~(DA9052_ALARMY_TICKON)));

	ret = priv->da9052->write(priv->da9052, &ssc_msg);
	if (ret != 0) {
		da9052_unlock(priv->da9052);
		goto err_ssc_comm;
	}

	/* Set TICK Alarm to 1 minute or 1 sec */
	/* Read ALARM MINUTES register */
	ssc_msg.addr = DA9052_ALARMMI_REG;
	ssc_msg.data = 0;

	ret = priv->da9052->read(priv->da9052, &ssc_msg);
	if (ret != 0) {
		da9052_unlock(priv->da9052);
		goto err_ssc_comm;
	}

	if (priv->is_min_alarm)
		/* Set 1 minute tick type */
		ssc_msg.data = (ssc_msg.data | DA9052_ALARMMI_TICKTYPE);
	else
		/* Set 1 sec tick type */
		ssc_msg.data = (ssc_msg.data & ~(DA9052_ALARMMI_TICKTYPE));

	ret = priv->da9052->write(priv->da9052, &ssc_msg);
	if (ret != 0) {
		da9052_unlock(priv->da9052);
		goto err_ssc_comm;
	}

	/* Enable/Disable Clock buffer in Power Down Mode */
	ssc_msg.addr = DA9052_PDDIS_REG;
	ssc_msg.data = 0;

	ret = priv->da9052->read(priv->da9052, &ssc_msg);
	if (ret != 0) {
		da9052_unlock(priv->da9052);
		goto err_ssc_comm;
	}

	if (priv->enable_clk_buffer)
		ssc_msg.data = (ssc_msg.data | DA9052_PDDIS_OUT32KPD);
	else
		ssc_msg.data = (ssc_msg.data & ~(DA9052_PDDIS_OUT32KPD));

	ret = priv->da9052->write(priv->da9052, &ssc_msg);
	if (ret != 0) {
		da9052_unlock(priv->da9052);
		goto err_ssc_comm;
	}

	/* Set clock trim frequency value */
	ssc_msg.addr = DA9052_OSCTRIM_REG;
	ssc_msg.data = priv->set_osc_trim_freq;

	ret = priv->da9052->write(priv->da9052, &ssc_msg);
	if (ret != 0) {
		da9052_unlock(priv->da9052);
		goto err_ssc_comm;
	}
	da9052_unlock(priv->da9052);

	priv->rtc = rtc_device_register(pdev->name,
			&pdev->dev, &da9052_rtc_ops, THIS_MODULE);
	if (IS_ERR(priv->rtc)) {
		ret = PTR_ERR(priv->rtc);
		goto err_ssc_comm;
	}
	return 0;

err_ssc_comm:
		priv->da9052->unregister_event_notifier
			(priv->da9052, &priv->eh_data);
err_register_alarm:
		platform_set_drvdata(pdev, NULL);
		kfree(priv);

	return ret;
}

static int __devexit da9052_rtc_remove(struct platform_device *pdev)
{
	struct da9052_rtc *priv = platform_get_drvdata(pdev);
	rtc_device_unregister(priv->rtc);
	da9052_lock(priv->da9052);
	priv->da9052->unregister_event_notifier(priv->da9052, &priv->eh_data);
	da9052_unlock(priv->da9052);
	platform_set_drvdata(pdev, NULL);
	kfree(priv);
	return 0;
}

static struct platform_driver da9052_rtc_driver = {
	.probe = da9052_rtc_probe,
	.remove = __devexit_p(da9052_rtc_remove),
	.driver = {
		.name = DRIVER_NAME,
		.owner = THIS_MODULE,
	},
};


static int __init da9052_rtc_init(void)
{
	return platform_driver_register(&da9052_rtc_driver);
}
module_init(da9052_rtc_init);

static void __exit da9052_rtc_exit(void)
{
	platform_driver_unregister(&da9052_rtc_driver);
}
module_exit(da9052_rtc_exit);

MODULE_AUTHOR("Dialog Semiconductor Ltd <dchen@diasemi.com>");
MODULE_DESCRIPTION("RTC driver for Dialog DA9052 PMIC");
MODULE_LICENSE("GPL v2");
MODULE_ALIAS("platform:" DRIVER_NAME);