[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / rtc / rtc-max8997.c

/*
 * RTC driver for Maxim MAX8997
 *
 * Copyright (C) 2013 Samsung Electronics Co.Ltd
 *
 *  based on rtc-max8998.c
 *
 *  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.
 *
 */

#include <linux/slab.h>
#include <linux/rtc.h>
#include <linux/delay.h>
#include <linux/mutex.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/mfd/max8997-private.h>
#include <linux/irqdomain.h>

/* Module parameter for WTSR function control */
static int wtsr_en = 1;
module_param(wtsr_en, int, 0444);
MODULE_PARM_DESC(wtsr_en, "Watchdog Timeout & Software Reset (default=on)");
/* Module parameter for SMPL function control */
static int smpl_en = 1;
module_param(smpl_en, int, 0444);
MODULE_PARM_DESC(smpl_en, "Sudden Momentary Power Loss (default=on)");

/* RTC Control Register */
#define BCD_EN_SHIFT			0
#define BCD_EN_MASK			(1 << BCD_EN_SHIFT)
#define MODEL24_SHIFT			1
#define MODEL24_MASK			(1 << MODEL24_SHIFT)
/* RTC Update Register1 */
#define RTC_UDR_SHIFT			0
#define RTC_UDR_MASK			(1 << RTC_UDR_SHIFT)
/* WTSR and SMPL Register */
#define WTSRT_SHIFT			0
#define SMPLT_SHIFT			2
#define WTSR_EN_SHIFT			6
#define SMPL_EN_SHIFT			7
#define WTSRT_MASK			(3 << WTSRT_SHIFT)
#define SMPLT_MASK			(3 << SMPLT_SHIFT)
#define WTSR_EN_MASK			(1 << WTSR_EN_SHIFT)
#define SMPL_EN_MASK			(1 << SMPL_EN_SHIFT)
/* RTC Hour register */
#define HOUR_PM_SHIFT			6
#define HOUR_PM_MASK			(1 << HOUR_PM_SHIFT)
/* RTC Alarm Enable */
#define ALARM_ENABLE_SHIFT		7
#define ALARM_ENABLE_MASK		(1 << ALARM_ENABLE_SHIFT)

enum {
	RTC_SEC = 0,
	RTC_MIN,
	RTC_HOUR,
	RTC_WEEKDAY,
	RTC_MONTH,
	RTC_YEAR,
	RTC_DATE,
	RTC_NR_TIME
};

struct max8997_rtc_info {
	struct device		*dev;
	struct max8997_dev	*max8997;
	struct i2c_client	*rtc;
	struct rtc_device	*rtc_dev;
	struct mutex		lock;
	int virq;
	int rtc_24hr_mode;
};

static void max8997_rtc_data_to_tm(u8 *data, struct rtc_time *tm,
				   int rtc_24hr_mode)
{
	tm->tm_sec = data[RTC_SEC] & 0x7f;
	tm->tm_min = data[RTC_MIN] & 0x7f;
	if (rtc_24hr_mode)
		tm->tm_hour = data[RTC_HOUR] & 0x1f;
	else {
		tm->tm_hour = data[RTC_HOUR] & 0x0f;
		if (data[RTC_HOUR] & HOUR_PM_MASK)
			tm->tm_hour += 12;
	}

	tm->tm_wday = fls(data[RTC_WEEKDAY] & 0x7f) - 1;
	tm->tm_mday = data[RTC_DATE] & 0x1f;
	tm->tm_mon = (data[RTC_MONTH] & 0x0f) - 1;
	tm->tm_year = (data[RTC_YEAR] & 0x7f) + 100;
	tm->tm_yday = 0;
	tm->tm_isdst = 0;
}

static int max8997_rtc_tm_to_data(struct rtc_time *tm, u8 *data)
{
	data[RTC_SEC] = tm->tm_sec;
	data[RTC_MIN] = tm->tm_min;
	data[RTC_HOUR] = tm->tm_hour;
	data[RTC_WEEKDAY] = 1 << tm->tm_wday;
	data[RTC_DATE] = tm->tm_mday;
	data[RTC_MONTH] = tm->tm_mon + 1;
	data[RTC_YEAR] = tm->tm_year > 100 ? (tm->tm_year - 100) : 0 ;

	if (tm->tm_year < 100) {
		pr_warn("%s: MAX8997 RTC cannot handle the year %d."
			"Assume it's 2000.\n", __func__, 1900 + tm->tm_year);
		return -EINVAL;
	}
	return 0;
}

static inline int max8997_rtc_set_update_reg(struct max8997_rtc_info *info)
{
	int ret;

	ret = max8997_write_reg(info->rtc, MAX8997_RTC_UPDATE1,
						RTC_UDR_MASK);
	if (ret < 0)
		dev_err(info->dev, "%s: fail to write update reg(%d)\n",
				__func__, ret);
	else {
		/* Minimum 16ms delay required before RTC update.
		 * Otherwise, we may read and update based on out-of-date
		 * value */
		msleep(20);
	}

	return ret;
}

static int max8997_rtc_read_time(struct device *dev, struct rtc_time *tm)
{
	struct max8997_rtc_info *info = dev_get_drvdata(dev);
	u8 data[RTC_NR_TIME];
	int ret;

	mutex_lock(&info->lock);
	ret = max8997_bulk_read(info->rtc, MAX8997_RTC_SEC, RTC_NR_TIME, data);
	mutex_unlock(&info->lock);

	if (ret < 0) {
		dev_err(info->dev, "%s: fail to read time reg(%d)\n", __func__,
				ret);
		return ret;
	}

	max8997_rtc_data_to_tm(data, tm, info->rtc_24hr_mode);

	return rtc_valid_tm(tm);
}

static int max8997_rtc_set_time(struct device *dev, struct rtc_time *tm)
{
	struct max8997_rtc_info *info = dev_get_drvdata(dev);
	u8 data[RTC_NR_TIME];
	int ret;

	ret = max8997_rtc_tm_to_data(tm, data);
	if (ret < 0)
		return ret;

	mutex_lock(&info->lock);

	ret = max8997_bulk_write(info->rtc, MAX8997_RTC_SEC, RTC_NR_TIME, data);
	if (ret < 0) {
		dev_err(info->dev, "%s: fail to write time reg(%d)\n", __func__,
				ret);
		goto out;
	}

	ret = max8997_rtc_set_update_reg(info);
out:
	mutex_unlock(&info->lock);
	return ret;
}

static int max8997_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
{
	struct max8997_rtc_info *info = dev_get_drvdata(dev);
	u8 data[RTC_NR_TIME];
	u8 val;
	int i, ret;

	mutex_lock(&info->lock);

	ret = max8997_bulk_read(info->rtc, MAX8997_RTC_ALARM1_SEC, RTC_NR_TIME,
			data);
	if (ret < 0) {
		dev_err(info->dev, "%s:%d fail to read alarm reg(%d)\n",
				__func__, __LINE__, ret);
		goto out;
	}

	max8997_rtc_data_to_tm(data, &alrm->time, info->rtc_24hr_mode);

	alrm->enabled = 0;
	for (i = 0; i < RTC_NR_TIME; i++) {
		if (data[i] & ALARM_ENABLE_MASK) {
			alrm->enabled = 1;
			break;
		}
	}

	alrm->pending = 0;
	ret = max8997_read_reg(info->max8997->i2c, MAX8997_REG_STATUS1, &val);
	if (ret < 0) {
		dev_err(info->dev, "%s:%d fail to read status1 reg(%d)\n",
				__func__, __LINE__, ret);
		goto out;
	}

	if (val & (1 << 4)) /* RTCA1 */
		alrm->pending = 1;

out:
	mutex_unlock(&info->lock);
	return 0;
}

static int max8997_rtc_stop_alarm(struct max8997_rtc_info *info)
{
	u8 data[RTC_NR_TIME];
	int ret, i;

	if (!mutex_is_locked(&info->lock))
		dev_warn(info->dev, "%s: should have mutex locked\n", __func__);

	ret = max8997_bulk_read(info->rtc, MAX8997_RTC_ALARM1_SEC, RTC_NR_TIME,
				data);
	if (ret < 0) {
		dev_err(info->dev, "%s: fail to read alarm reg(%d)\n",
				__func__, ret);
		goto out;
	}

	for (i = 0; i < RTC_NR_TIME; i++)
		data[i] &= ~ALARM_ENABLE_MASK;

	ret = max8997_bulk_write(info->rtc, MAX8997_RTC_ALARM1_SEC, RTC_NR_TIME,
				 data);
	if (ret < 0) {
		dev_err(info->dev, "%s: fail to write alarm reg(%d)\n",
				__func__, ret);
		goto out;
	}

	ret = max8997_rtc_set_update_reg(info);
out:
	return ret;
}

static int max8997_rtc_start_alarm(struct max8997_rtc_info *info)
{
	u8 data[RTC_NR_TIME];
	int ret;

	if (!mutex_is_locked(&info->lock))
		dev_warn(info->dev, "%s: should have mutex locked\n", __func__);

	ret = max8997_bulk_read(info->rtc, MAX8997_RTC_ALARM1_SEC, RTC_NR_TIME,
				data);
	if (ret < 0) {
		dev_err(info->dev, "%s: fail to read alarm reg(%d)\n",
				__func__, ret);
		goto out;
	}

	data[RTC_SEC] |= (1 << ALARM_ENABLE_SHIFT);
	data[RTC_MIN] |= (1 << ALARM_ENABLE_SHIFT);
	data[RTC_HOUR] |= (1 << ALARM_ENABLE_SHIFT);
	data[RTC_WEEKDAY] &= ~ALARM_ENABLE_MASK;
	if (data[RTC_MONTH] & 0xf)
		data[RTC_MONTH] |= (1 << ALARM_ENABLE_SHIFT);
	if (data[RTC_YEAR] & 0x7f)
		data[RTC_YEAR] |= (1 << ALARM_ENABLE_SHIFT);
	if (data[RTC_DATE] & 0x1f)
		data[RTC_DATE] |= (1 << ALARM_ENABLE_SHIFT);

	ret = max8997_bulk_write(info->rtc, MAX8997_RTC_ALARM1_SEC, RTC_NR_TIME,
				 data);
	if (ret < 0) {
		dev_err(info->dev, "%s: fail to write alarm reg(%d)\n",
				__func__, ret);
		goto out;
	}

	ret = max8997_rtc_set_update_reg(info);
out:
	return ret;
}
static int max8997_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
{
	struct max8997_rtc_info *info = dev_get_drvdata(dev);
	u8 data[RTC_NR_TIME];
	int ret;

	ret = max8997_rtc_tm_to_data(&alrm->time, data);
	if (ret < 0)
		return ret;

	dev_info(info->dev, "%s: %d-%02d-%02d %02d:%02d:%02d\n", __func__,
			data[RTC_YEAR] + 2000, data[RTC_MONTH], data[RTC_DATE],
			data[RTC_HOUR], data[RTC_MIN], data[RTC_SEC]);

	mutex_lock(&info->lock);

	ret = max8997_rtc_stop_alarm(info);
	if (ret < 0)
		goto out;

	ret = max8997_bulk_write(info->rtc, MAX8997_RTC_ALARM1_SEC, RTC_NR_TIME,
				data);
	if (ret < 0) {
		dev_err(info->dev, "%s: fail to write alarm reg(%d)\n",
				__func__, ret);
		goto out;
	}

	ret = max8997_rtc_set_update_reg(info);
	if (ret < 0)
		goto out;

	if (alrm->enabled)
		ret = max8997_rtc_start_alarm(info);
out:
	mutex_unlock(&info->lock);
	return ret;
}

static int max8997_rtc_alarm_irq_enable(struct device *dev,
					unsigned int enabled)
{
	struct max8997_rtc_info *info = dev_get_drvdata(dev);
	int ret;

	mutex_lock(&info->lock);
	if (enabled)
		ret = max8997_rtc_start_alarm(info);
	else
		ret = max8997_rtc_stop_alarm(info);
	mutex_unlock(&info->lock);

	return ret;
}

static irqreturn_t max8997_rtc_alarm_irq(int irq, void *data)
{
	struct max8997_rtc_info *info = data;

	dev_info(info->dev, "%s:irq(%d)\n", __func__, irq);

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

	return IRQ_HANDLED;
}

static const struct rtc_class_ops max8997_rtc_ops = {
	.read_time = max8997_rtc_read_time,
	.set_time = max8997_rtc_set_time,
	.read_alarm = max8997_rtc_read_alarm,
	.set_alarm = max8997_rtc_set_alarm,
	.alarm_irq_enable = max8997_rtc_alarm_irq_enable,
};

static void max8997_rtc_enable_wtsr(struct max8997_rtc_info *info, bool enable)
{
	int ret;
	u8 val, mask;

	if (!wtsr_en)
		return;

	if (enable)
		val = (1 << WTSR_EN_SHIFT) | (3 << WTSRT_SHIFT);
	else
		val = 0;

	mask = WTSR_EN_MASK | WTSRT_MASK;

	dev_info(info->dev, "%s: %s WTSR\n", __func__,
			enable ? "enable" : "disable");

	ret = max8997_update_reg(info->rtc, MAX8997_RTC_WTSR_SMPL, val, mask);
	if (ret < 0) {
		dev_err(info->dev, "%s: fail to update WTSR reg(%d)\n",
				__func__, ret);
		return;
	}

	max8997_rtc_set_update_reg(info);
}

static void max8997_rtc_enable_smpl(struct max8997_rtc_info *info, bool enable)
{
	int ret;
	u8 val, mask;

	if (!smpl_en)
		return;

	if (enable)
		val = (1 << SMPL_EN_SHIFT) | (0 << SMPLT_SHIFT);
	else
		val = 0;

	mask = SMPL_EN_MASK | SMPLT_MASK;

	dev_info(info->dev, "%s: %s SMPL\n", __func__,
			enable ? "enable" : "disable");

	ret = max8997_update_reg(info->rtc, MAX8997_RTC_WTSR_SMPL, val, mask);
	if (ret < 0) {
		dev_err(info->dev, "%s: fail to update SMPL reg(%d)\n",
				__func__, ret);
		return;
	}

	max8997_rtc_set_update_reg(info);

	val = 0;
	max8997_read_reg(info->rtc, MAX8997_RTC_WTSR_SMPL, &val);
	pr_info("%s: WTSR_SMPL(0x%02x)\n", __func__, val);
}

static int max8997_rtc_init_reg(struct max8997_rtc_info *info)
{
	u8 data[2];
	int ret;

	/* Set RTC control register : Binary mode, 24hour mdoe */
	data[0] = (1 << BCD_EN_SHIFT) | (1 << MODEL24_SHIFT);
	data[1] = (0 << BCD_EN_SHIFT) | (1 << MODEL24_SHIFT);

	info->rtc_24hr_mode = 1;

	ret = max8997_bulk_write(info->rtc, MAX8997_RTC_CTRLMASK, 2, data);
	if (ret < 0) {
		dev_err(info->dev, "%s: fail to write controlm reg(%d)\n",
				__func__, ret);
		return ret;
	}

	ret = max8997_rtc_set_update_reg(info);
	return ret;
}

static int max8997_rtc_probe(struct platform_device *pdev)
{
	struct max8997_dev *max8997 = dev_get_drvdata(pdev->dev.parent);
	struct max8997_rtc_info *info;
	int ret, virq;

	info = devm_kzalloc(&pdev->dev, sizeof(struct max8997_rtc_info),
			GFP_KERNEL);
	if (!info)
		return -ENOMEM;

	mutex_init(&info->lock);
	info->dev = &pdev->dev;
	info->max8997 = max8997;
	info->rtc = max8997->rtc;

	platform_set_drvdata(pdev, info);

	ret = max8997_rtc_init_reg(info);

	if (ret < 0) {
		dev_err(&pdev->dev, "Failed to initialize RTC reg:%d\n", ret);
		return ret;
	}

	max8997_rtc_enable_wtsr(info, true);
	max8997_rtc_enable_smpl(info, true);

	device_init_wakeup(&pdev->dev, 1);

	info->rtc_dev = devm_rtc_device_register(&pdev->dev, "max8997-rtc",
					&max8997_rtc_ops, THIS_MODULE);

	if (IS_ERR(info->rtc_dev)) {
		ret = PTR_ERR(info->rtc_dev);
		dev_err(&pdev->dev, "Failed to register RTC device: %d\n", ret);
		return ret;
	}

	virq = irq_create_mapping(max8997->irq_domain, MAX8997_PMICIRQ_RTCA1);
	if (!virq) {
		dev_err(&pdev->dev, "Failed to create mapping alarm IRQ\n");
		ret = -ENXIO;
		goto err_out;
	}
	info->virq = virq;

	ret = devm_request_threaded_irq(&pdev->dev, virq, NULL,
				max8997_rtc_alarm_irq, 0,
				"rtc-alarm0", info);
	if (ret < 0)
		dev_err(&pdev->dev, "Failed to request alarm IRQ: %d: %d\n",
			info->virq, ret);

err_out:
	return ret;
}

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

static void max8997_rtc_shutdown(struct platform_device *pdev)
{
	struct max8997_rtc_info *info = platform_get_drvdata(pdev);

	max8997_rtc_enable_wtsr(info, false);
	max8997_rtc_enable_smpl(info, false);
}

static const struct platform_device_id rtc_id[] = {
	{ "max8997-rtc", 0 },
	{},
};

static struct platform_driver max8997_rtc_driver = {
	.driver		= {
		.name	= "max8997-rtc",
		.owner	= THIS_MODULE,
	},
	.probe		= max8997_rtc_probe,
	.remove		= max8997_rtc_remove,
	.shutdown	= max8997_rtc_shutdown,
	.id_table	= rtc_id,
};

module_platform_driver(max8997_rtc_driver);

MODULE_DESCRIPTION("Maxim MAX8997 RTC driver");
MODULE_AUTHOR("<ms925.kim@samsung.com>");
MODULE_LICENSE("GPL");
Commit	Line	Data
5e0b2704 JL	1	/*
	2	* RTC driver for Maxim MAX8997
	3	*
	4	* Copyright (C) 2013 Samsung Electronics Co.Ltd
	5	*
	6	* based on rtc-max8998.c
	7	*
	8	* This program is free software; you can redistribute it and/or modify it
	9	* under the terms of the GNU General Public License as published by the
	10	* Free Software Foundation; either version 2 of the License, or (at your
	11	* option) any later version.
	12	*
	13	*/
	14
	15	#include <linux/slab.h>
	16	#include <linux/rtc.h>
	17	#include <linux/delay.h>
	18	#include <linux/mutex.h>
	19	#include <linux/module.h>
	20	#include <linux/platform_device.h>
	21	#include <linux/mfd/max8997-private.h>
	22	#include <linux/irqdomain.h>
	23
	24	/* Module parameter for WTSR function control */
	25	static int wtsr_en = 1;
	26	module_param(wtsr_en, int, 0444);
a895d57d	27	MODULE_PARM_DESC(wtsr_en, "Watchdog Timeout & Software Reset (default=on)");
5e0b2704 JL	28	/* Module parameter for SMPL function control */
	29	static int smpl_en = 1;
	30	module_param(smpl_en, int, 0444);
	31	MODULE_PARM_DESC(smpl_en, "Sudden Momentary Power Loss (default=on)");
	32
	33	/* RTC Control Register */
	34	#define BCD_EN_SHIFT 0
	35	#define BCD_EN_MASK (1 << BCD_EN_SHIFT)
	36	#define MODEL24_SHIFT 1
	37	#define MODEL24_MASK (1 << MODEL24_SHIFT)
	38	/* RTC Update Register1 */
	39	#define RTC_UDR_SHIFT 0
	40	#define RTC_UDR_MASK (1 << RTC_UDR_SHIFT)
	41	/* WTSR and SMPL Register */
	42	#define WTSRT_SHIFT 0
	43	#define SMPLT_SHIFT 2
	44	#define WTSR_EN_SHIFT 6
	45	#define SMPL_EN_SHIFT 7
	46	#define WTSRT_MASK (3 << WTSRT_SHIFT)
	47	#define SMPLT_MASK (3 << SMPLT_SHIFT)
	48	#define WTSR_EN_MASK (1 << WTSR_EN_SHIFT)
	49	#define SMPL_EN_MASK (1 << SMPL_EN_SHIFT)
	50	/* RTC Hour register */
	51	#define HOUR_PM_SHIFT 6
	52	#define HOUR_PM_MASK (1 << HOUR_PM_SHIFT)
	53	/* RTC Alarm Enable */
	54	#define ALARM_ENABLE_SHIFT 7
	55	#define ALARM_ENABLE_MASK (1 << ALARM_ENABLE_SHIFT)
	56
	57	enum {
	58	RTC_SEC = 0,
	59	RTC_MIN,
	60	RTC_HOUR,
	61	RTC_WEEKDAY,
	62	RTC_MONTH,
	63	RTC_YEAR,
	64	RTC_DATE,
	65	RTC_NR_TIME
	66	};
	67
	68	struct max8997_rtc_info {
	69	struct device *dev;
	70	struct max8997_dev *max8997;
	71	struct i2c_client *rtc;
	72	struct rtc_device *rtc_dev;
	73	struct mutex lock;
	74	int virq;
	75	int rtc_24hr_mode;
	76	};
	77
	78	static void max8997_rtc_data_to_tm(u8 data, struct rtc_time tm,
	79	int rtc_24hr_mode)
	80	{
	81	tm->tm_sec = data[RTC_SEC] & 0x7f;
	82	tm->tm_min = data[RTC_MIN] & 0x7f;
	83	if (rtc_24hr_mode)
	84	tm->tm_hour = data[RTC_HOUR] & 0x1f;
	85	else {
	86	tm->tm_hour = data[RTC_HOUR] & 0x0f;
	87	if (data[RTC_HOUR] & HOUR_PM_MASK)
	88	tm->tm_hour += 12;
	89	}
	90
	91	tm->tm_wday = fls(data[RTC_WEEKDAY] & 0x7f) - 1;
92	tm->tm_mday = data[RTC_DATE] & 0x1f;
93	tm->tm_mon = (data[RTC_MONTH] & 0x0f) - 1;
94	tm->tm_year = (data[RTC_YEAR] & 0x7f) + 100;
95	tm->tm_yday = 0;
96	tm->tm_isdst = 0;
97	}
98
99	static int max8997_rtc_tm_to_data(struct rtc_time tm, u8 data)
100	{
101	data[RTC_SEC] = tm->tm_sec;
102	data[RTC_MIN] = tm->tm_min;
103	data[RTC_HOUR] = tm->tm_hour;
104	data[RTC_WEEKDAY] = 1 << tm->tm_wday;
105	data[RTC_DATE] = tm->tm_mday;
106	data[RTC_MONTH] = tm->tm_mon + 1;
107	data[RTC_YEAR] = tm->tm_year > 100 ? (tm->tm_year - 100) : 0 ;
108
109	if (tm->tm_year < 100) {
110	pr_warn("%s: MAX8997 RTC cannot handle the year %d."
111	"Assume it's 2000.\n", __func__, 1900 + tm->tm_year);
112	return -EINVAL;
113	}
114	return 0;
115	}
116
117	static inline int max8997_rtc_set_update_reg(struct max8997_rtc_info *info)
118	{
119	int ret;
120
121	ret = max8997_write_reg(info->rtc, MAX8997_RTC_UPDATE1,
122	RTC_UDR_MASK);
123	if (ret < 0)
124	dev_err(info->dev, "%s: fail to write update reg(%d)\n",
125	__func__, ret);
126	else {
127	/* Minimum 16ms delay required before RTC update.
128	* Otherwise, we may read and update based on out-of-date
129	* value */
130	msleep(20);
131	}
132
133	return ret;
134	}
135
136	static int max8997_rtc_read_time(struct device dev, struct rtc_time tm)
137	{
138	struct max8997_rtc_info *info = dev_get_drvdata(dev);
139	u8 data[RTC_NR_TIME];
140	int ret;
141
142	mutex_lock(&info->lock);
143	ret = max8997_bulk_read(info->rtc, MAX8997_RTC_SEC, RTC_NR_TIME, data);
144	mutex_unlock(&info->lock);
145
146	if (ret < 0) {
147	dev_err(info->dev, "%s: fail to read time reg(%d)\n", __func__,
148	ret);
149	return ret;
150	}
151
152	max8997_rtc_data_to_tm(data, tm, info->rtc_24hr_mode);
153
154	return rtc_valid_tm(tm);
155	}
156
157	static int max8997_rtc_set_time(struct device dev, struct rtc_time tm)
158	{
159	struct max8997_rtc_info *info = dev_get_drvdata(dev);
160	u8 data[RTC_NR_TIME];
161	int ret;
162
163	ret = max8997_rtc_tm_to_data(tm, data);
164	if (ret < 0)
165	return ret;
166
167	mutex_lock(&info->lock);
168
169	ret = max8997_bulk_write(info->rtc, MAX8997_RTC_SEC, RTC_NR_TIME, data);
170	if (ret < 0) {
171	dev_err(info->dev, "%s: fail to write time reg(%d)\n", __func__,
172	ret);
173	goto out;
174	}
175
176	ret = max8997_rtc_set_update_reg(info);
177	out:
178	mutex_unlock(&info->lock);
179	return ret;
180	}
181
182	static int max8997_rtc_read_alarm(struct device dev, struct rtc_wkalrm alrm)
183	{
184	struct max8997_rtc_info *info = dev_get_drvdata(dev);
185	u8 data[RTC_NR_TIME];
186	u8 val;
187	int i, ret;
188
189	mutex_lock(&info->lock);
190
191	ret = max8997_bulk_read(info->rtc, MAX8997_RTC_ALARM1_SEC, RTC_NR_TIME,
192	data);
193	if (ret < 0) {
194	dev_err(info->dev, "%s:%d fail to read alarm reg(%d)\n",
195	__func__, __LINE__, ret);
196	goto out;
197	}
198
199	max8997_rtc_data_to_tm(data, &alrm->time, info->rtc_24hr_mode);
200
201	alrm->enabled = 0;
202	for (i = 0; i < RTC_NR_TIME; i++) {
203	if (data[i] & ALARM_ENABLE_MASK) {
204	alrm->enabled = 1;
205	break;
206	}
207	}
208
209	alrm->pending = 0;
210	ret = max8997_read_reg(info->max8997->i2c, MAX8997_REG_STATUS1, &val);
211	if (ret < 0) {
212	dev_err(info->dev, "%s:%d fail to read status1 reg(%d)\n",
213	__func__, __LINE__, ret);
214	goto out;
215	}
216
217	if (val & (1 << 4)) /* RTCA1 */
218	alrm->pending = 1;
219
220	out:
221	mutex_unlock(&info->lock);
222	return 0;
223	}
224
225	static int max8997_rtc_stop_alarm(struct max8997_rtc_info *info)
226	{
227	u8 data[RTC_NR_TIME];
228	int ret, i;
229
230	if (!mutex_is_locked(&info->lock))
231	dev_warn(info->dev, "%s: should have mutex locked\n", __func__);
232
233	ret = max8997_bulk_read(info->rtc, MAX8997_RTC_ALARM1_SEC, RTC_NR_TIME,
234	data);
235	if (ret < 0) {
236	dev_err(info->dev, "%s: fail to read alarm reg(%d)\n",
237	__func__, ret);
238	goto out;
239	}
240
241	for (i = 0; i < RTC_NR_TIME; i++)
242	data[i] &= ~ALARM_ENABLE_MASK;
243
244	ret = max8997_bulk_write(info->rtc, MAX8997_RTC_ALARM1_SEC, RTC_NR_TIME,
245	data);
246	if (ret < 0) {
247	dev_err(info->dev, "%s: fail to write alarm reg(%d)\n",
248	__func__, ret);
249	goto out;
250	}
251
252	ret = max8997_rtc_set_update_reg(info);
253	out:
254	return ret;
255	}
256
257	static int max8997_rtc_start_alarm(struct max8997_rtc_info *info)
258	{
259	u8 data[RTC_NR_TIME];
260	int ret;
261
262	if (!mutex_is_locked(&info->lock))
263	dev_warn(info->dev, "%s: should have mutex locked\n", __func__);
264
265	ret = max8997_bulk_read(info->rtc, MAX8997_RTC_ALARM1_SEC, RTC_NR_TIME,
266	data);
267	if (ret < 0) {
268	dev_err(info->dev, "%s: fail to read alarm reg(%d)\n",
269	__func__, ret);
270	goto out;
271	}
272
273	data[RTC_SEC] \|= (1 << ALARM_ENABLE_SHIFT);
274	data[RTC_MIN] \|= (1 << ALARM_ENABLE_SHIFT);
275	data[RTC_HOUR] \|= (1 << ALARM_ENABLE_SHIFT);
276	data[RTC_WEEKDAY] &= ~ALARM_ENABLE_MASK;
277	if (data[RTC_MONTH] & 0xf)
278	data[RTC_MONTH] \|= (1 << ALARM_ENABLE_SHIFT);
279	if (data[RTC_YEAR] & 0x7f)
280	data[RTC_YEAR] \|= (1 << ALARM_ENABLE_SHIFT);
281	if (data[RTC_DATE] & 0x1f)
282	data[RTC_DATE] \|= (1 << ALARM_ENABLE_SHIFT);
283
284	ret = max8997_bulk_write(info->rtc, MAX8997_RTC_ALARM1_SEC, RTC_NR_TIME,
285	data);
286	if (ret < 0) {
287	dev_err(info->dev, "%s: fail to write alarm reg(%d)\n",
288	__func__, ret);
289	goto out;
290	}
291
292	ret = max8997_rtc_set_update_reg(info);
293	out:
294	return ret;
295	}
296	static int max8997_rtc_set_alarm(struct device dev, struct rtc_wkalrm alrm)
297	{
298	struct max8997_rtc_info *info = dev_get_drvdata(dev);
299	u8 data[RTC_NR_TIME];
300	int ret;
301
302	ret = max8997_rtc_tm_to_data(&alrm->time, data);
303	if (ret < 0)
304	return ret;
305
306	dev_info(info->dev, "%s: %d-%02d-%02d %02d:%02d:%02d\n", __func__,
307	data[RTC_YEAR] + 2000, data[RTC_MONTH], data[RTC_DATE],
308	data[RTC_HOUR], data[RTC_MIN], data[RTC_SEC]);
309
310	mutex_lock(&info->lock);
311
312	ret = max8997_rtc_stop_alarm(info);
313	if (ret < 0)
314	goto out;
315
316	ret = max8997_bulk_write(info->rtc, MAX8997_RTC_ALARM1_SEC, RTC_NR_TIME,
317	data);
318	if (ret < 0) {
319	dev_err(info->dev, "%s: fail to write alarm reg(%d)\n",
320	__func__, ret);
321	goto out;
322	}
323
324	ret = max8997_rtc_set_update_reg(info);
325	if (ret < 0)
326	goto out;
327
328	if (alrm->enabled)
329	ret = max8997_rtc_start_alarm(info);
330	out:
331	mutex_unlock(&info->lock);
332	return ret;
333	}
334
335	static int max8997_rtc_alarm_irq_enable(struct device *dev,
336	unsigned int enabled)
337	{
338	struct max8997_rtc_info *info = dev_get_drvdata(dev);
339	int ret;
340
341	mutex_lock(&info->lock);
342	if (enabled)
343	ret = max8997_rtc_start_alarm(info);
344	else
345	ret = max8997_rtc_stop_alarm(info);
346	mutex_unlock(&info->lock);
347
348	return ret;
349	}
350
351	static irqreturn_t max8997_rtc_alarm_irq(int irq, void *data)
352	{
353	struct max8997_rtc_info *info = data;
354
355	dev_info(info->dev, "%s:irq(%d)\n", __func__, irq);
356
357	rtc_update_irq(info->rtc_dev, 1, RTC_IRQF \| RTC_AF);
358
359	return IRQ_HANDLED;
360	}
361
362	static const struct rtc_class_ops max8997_rtc_ops = {
363	.read_time = max8997_rtc_read_time,
364	.set_time = max8997_rtc_set_time,
365	.read_alarm = max8997_rtc_read_alarm,
366	.set_alarm = max8997_rtc_set_alarm,
367	.alarm_irq_enable = max8997_rtc_alarm_irq_enable,
368	};
369
370	static void max8997_rtc_enable_wtsr(struct max8997_rtc_info *info, bool enable)
371	{
372	int ret;
373	u8 val, mask;
374
375	if (!wtsr_en)
376	return;
377
378	if (enable)
379	val = (1 << WTSR_EN_SHIFT) \| (3 << WTSRT_SHIFT);
380	else
381	val = 0;
382
383	mask = WTSR_EN_MASK \| WTSRT_MASK;
384
385	dev_info(info->dev, "%s: %s WTSR\n", __func__,
386	enable ? "enable" : "disable");
387
388	ret = max8997_update_reg(info->rtc, MAX8997_RTC_WTSR_SMPL, val, mask);
389	if (ret < 0) {
390	dev_err(info->dev, "%s: fail to update WTSR reg(%d)\n",
391	__func__, ret);
392	return;
393	}
394
395	max8997_rtc_set_update_reg(info);
396	}
397
398	static void max8997_rtc_enable_smpl(struct max8997_rtc_info *info, bool enable)
399	{
400	int ret;
401	u8 val, mask;
402
403	if (!smpl_en)
404	return;
405
406	if (enable)
407	val = (1 << SMPL_EN_SHIFT) \| (0 << SMPLT_SHIFT);
408	else
409	val = 0;
410
411	mask = SMPL_EN_MASK \| SMPLT_MASK;
412
413	dev_info(info->dev, "%s: %s SMPL\n", __func__,
414	enable ? "enable" : "disable");
415
416	ret = max8997_update_reg(info->rtc, MAX8997_RTC_WTSR_SMPL, val, mask);
417	if (ret < 0) {
418	dev_err(info->dev, "%s: fail to update SMPL reg(%d)\n",
419	__func__, ret);
420	return;
421	}
422
423	max8997_rtc_set_update_reg(info);
424
425	val = 0;
426	max8997_read_reg(info->rtc, MAX8997_RTC_WTSR_SMPL, &val);
427	pr_info("%s: WTSR_SMPL(0x%02x)\n", __func__, val);
428	}
429
430	static int max8997_rtc_init_reg(struct max8997_rtc_info *info)
431	{
432	u8 data[2];
433	int ret;
434
435	/* Set RTC control register : Binary mode, 24hour mdoe */
436	data[0] = (1 << BCD_EN_SHIFT) \| (1 << MODEL24_SHIFT);
437	data[1] = (0 << BCD_EN_SHIFT) \| (1 << MODEL24_SHIFT);
438
439	info->rtc_24hr_mode = 1;
440
441	ret = max8997_bulk_write(info->rtc, MAX8997_RTC_CTRLMASK, 2, data);
442	if (ret < 0) {
443	dev_err(info->dev, "%s: fail to write controlm reg(%d)\n",
444	__func__, ret);
445	return ret;
446	}
447
448	ret = max8997_rtc_set_update_reg(info);
449	return ret;
450	}
451
452	static int max8997_rtc_probe(struct platform_device *pdev)
453	{
454	struct max8997_dev *max8997 = dev_get_drvdata(pdev->dev.parent);
455	struct max8997_rtc_info *info;
456	int ret, virq;
457
458	info = devm_kzalloc(&pdev->dev, sizeof(struct max8997_rtc_info),
459	GFP_KERNEL);
460	if (!info)
461	return -ENOMEM;
462
463	mutex_init(&info->lock);
464	info->dev = &pdev->dev;
465	info->max8997 = max8997;
466	info->rtc = max8997->rtc;
467
468	platform_set_drvdata(pdev, info);
469
470	ret = max8997_rtc_init_reg(info);
471
472	if (ret < 0) {
473	dev_err(&pdev->dev, "Failed to initialize RTC reg:%d\n", ret);
474	return ret;
475	}
476
477	max8997_rtc_enable_wtsr(info, true);
478	max8997_rtc_enable_smpl(info, true);
479
480	device_init_wakeup(&pdev->dev, 1);
481
4ce903cc JH	482	info->rtc_dev = devm_rtc_device_register(&pdev->dev, "max8997-rtc",
4ce903cc JH	483	&max8997_rtc_ops, THIS_MODULE);
5e0b2704 JL	484
	485	if (IS_ERR(info->rtc_dev)) {
	486	ret = PTR_ERR(info->rtc_dev);
	487	dev_err(&pdev->dev, "Failed to register RTC device: %d\n", ret);
	488	return ret;
	489	}
	490
	491	virq = irq_create_mapping(max8997->irq_domain, MAX8997_PMICIRQ_RTCA1);
	492	if (!virq) {
	493	dev_err(&pdev->dev, "Failed to create mapping alarm IRQ\n");
406dc004	494	ret = -ENXIO;
5e0b2704 JL	495	goto err_out;
	496	}
	497	info->virq = virq;
	498
c1879fe8 JH	499	ret = devm_request_threaded_irq(&pdev->dev, virq, NULL,
c1879fe8 JH	500	max8997_rtc_alarm_irq, 0,
5e0b2704	501	"rtc-alarm0", info);
406dc004	502	if (ret < 0)
5e0b2704 JL	503	dev_err(&pdev->dev, "Failed to request alarm IRQ: %d: %d\n",
5e0b2704 JL	504	info->virq, ret);
5e0b2704 JL	505
5e0b2704 JL	506	err_out:
5e0b2704 JL	507	return ret;
	508	}
	509
	510	static int max8997_rtc_remove(struct platform_device *pdev)
	511	{
5e0b2704 JL	512	return 0;
	513	}
	514
	515	static void max8997_rtc_shutdown(struct platform_device *pdev)
	516	{
	517	struct max8997_rtc_info *info = platform_get_drvdata(pdev);
	518
	519	max8997_rtc_enable_wtsr(info, false);
	520	max8997_rtc_enable_smpl(info, false);
	521	}
	522
	523	static const struct platform_device_id rtc_id[] = {
	524	{ "max8997-rtc", 0 },
	525	{},
	526	};
	527
	528	static struct platform_driver max8997_rtc_driver = {
	529	.driver = {
	530	.name = "max8997-rtc",
	531	.owner = THIS_MODULE,
	532	},
	533	.probe = max8997_rtc_probe,
	534	.remove = max8997_rtc_remove,
	535	.shutdown = max8997_rtc_shutdown,
	536	.id_table = rtc_id,
	537	};
	538
	539	module_platform_driver(max8997_rtc_driver);
	540
	541	MODULE_DESCRIPTION("Maxim MAX8997 RTC driver");
	542	MODULE_AUTHOR("<ms925.kim@samsung.com>");
	543	MODULE_LICENSE("GPL");