[linux-2.6-block.git] / drivers / rtc / rtc-rv8803.c

/*
 * RTC driver for the Micro Crystal RV8803
 *
 * Copyright (C) 2015 Micro Crystal SA
 *
 * Alexandre Belloni <alexandre.belloni@free-electrons.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 */

#include <linux/bcd.h>
#include <linux/bitops.h>
#include <linux/log2.h>
#include <linux/i2c.h>
#include <linux/interrupt.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/rtc.h>

#define RV8803_I2C_TRY_COUNT		4

#define RV8803_SEC			0x00
#define RV8803_MIN			0x01
#define RV8803_HOUR			0x02
#define RV8803_WEEK			0x03
#define RV8803_DAY			0x04
#define RV8803_MONTH			0x05
#define RV8803_YEAR			0x06
#define RV8803_RAM			0x07
#define RV8803_ALARM_MIN		0x08
#define RV8803_ALARM_HOUR		0x09
#define RV8803_ALARM_WEEK_OR_DAY	0x0A
#define RV8803_EXT			0x0D
#define RV8803_FLAG			0x0E
#define RV8803_CTRL			0x0F

#define RV8803_EXT_WADA			BIT(6)

#define RV8803_FLAG_V1F			BIT(0)
#define RV8803_FLAG_V2F			BIT(1)
#define RV8803_FLAG_AF			BIT(3)
#define RV8803_FLAG_TF			BIT(4)
#define RV8803_FLAG_UF			BIT(5)

#define RV8803_CTRL_RESET		BIT(0)

#define RV8803_CTRL_EIE			BIT(2)
#define RV8803_CTRL_AIE			BIT(3)
#define RV8803_CTRL_TIE			BIT(4)
#define RV8803_CTRL_UIE			BIT(5)

struct rv8803_data {
	struct i2c_client *client;
	struct rtc_device *rtc;
	struct mutex flags_lock;
	u8 ctrl;
};

static int rv8803_read_reg(const struct i2c_client *client, u8 reg)
{
	int try = RV8803_I2C_TRY_COUNT;
	s32 ret;

	/*
	 * There is a 61µs window during which the RTC does not acknowledge I2C
	 * transfers. In that case, ensure that there are multiple attempts.
	 */
	do
		ret = i2c_smbus_read_byte_data(client, reg);
	while ((ret == -ENXIO || ret == -EIO) && --try);
	if (ret < 0)
		dev_err(&client->dev, "Unable to read register 0x%02x\n", reg);

	return ret;
}

static int rv8803_read_regs(const struct i2c_client *client,
			    u8 reg, u8 count, u8 *values)
{
	int try = RV8803_I2C_TRY_COUNT;
	s32 ret;

	do
		ret = i2c_smbus_read_i2c_block_data(client, reg, count, values);
	while ((ret == -ENXIO || ret == -EIO) && --try);
	if (ret != count) {
		dev_err(&client->dev,
			"Unable to read registers 0x%02x..0x%02x\n",
			reg, reg + count - 1);
		return ret < 0 ? ret : -EIO;
	}

	return 0;
}

static int rv8803_write_reg(const struct i2c_client *client, u8 reg, u8 value)
{
	int try = RV8803_I2C_TRY_COUNT;
	s32 ret;

	do
		ret = i2c_smbus_write_byte_data(client, reg, value);
	while ((ret == -ENXIO || ret == -EIO) && --try);
	if (ret)
		dev_err(&client->dev, "Unable to write register 0x%02x\n", reg);

	return ret;
}

static int rv8803_write_regs(const struct i2c_client *client,
			     u8 reg, u8 count, const u8 *values)
{
	int try = RV8803_I2C_TRY_COUNT;
	s32 ret;

	do
		ret = i2c_smbus_write_i2c_block_data(client, reg, count,
						     values);
	while ((ret == -ENXIO || ret == -EIO) && --try);
	if (ret)
		dev_err(&client->dev,
			"Unable to write registers 0x%02x..0x%02x\n",
			reg, reg + count - 1);

	return ret;
}

static irqreturn_t rv8803_handle_irq(int irq, void *dev_id)
{
	struct i2c_client *client = dev_id;
	struct rv8803_data *rv8803 = i2c_get_clientdata(client);
	unsigned long events = 0;
	int flags;

	mutex_lock(&rv8803->flags_lock);

	flags = rv8803_read_reg(client, RV8803_FLAG);
	if (flags <= 0) {
		mutex_unlock(&rv8803->flags_lock);
		return IRQ_NONE;
	}

	if (flags & RV8803_FLAG_V1F)
		dev_warn(&client->dev, "Voltage low, temperature compensation stopped.\n");

	if (flags & RV8803_FLAG_V2F)
		dev_warn(&client->dev, "Voltage low, data loss detected.\n");

	if (flags & RV8803_FLAG_TF) {
		flags &= ~RV8803_FLAG_TF;
		rv8803->ctrl &= ~RV8803_CTRL_TIE;
		events |= RTC_PF;
	}

	if (flags & RV8803_FLAG_AF) {
		flags &= ~RV8803_FLAG_AF;
		rv8803->ctrl &= ~RV8803_CTRL_AIE;
		events |= RTC_AF;
	}

	if (flags & RV8803_FLAG_UF) {
		flags &= ~RV8803_FLAG_UF;
		rv8803->ctrl &= ~RV8803_CTRL_UIE;
		events |= RTC_UF;
	}

	if (events) {
		rtc_update_irq(rv8803->rtc, 1, events);
		rv8803_write_reg(client, RV8803_FLAG, flags);
		rv8803_write_reg(rv8803->client, RV8803_CTRL, rv8803->ctrl);
	}

	mutex_unlock(&rv8803->flags_lock);

	return IRQ_HANDLED;
}

static int rv8803_get_time(struct device *dev, struct rtc_time *tm)
{
	struct rv8803_data *rv8803 = dev_get_drvdata(dev);
	u8 date1[7];
	u8 date2[7];
	u8 *date = date1;
	int ret, flags;

	flags = rv8803_read_reg(rv8803->client, RV8803_FLAG);
	if (flags < 0)
		return flags;

	if (flags & RV8803_FLAG_V2F) {
		dev_warn(dev, "Voltage low, data is invalid.\n");
		return -EINVAL;
	}

	ret = rv8803_read_regs(rv8803->client, RV8803_SEC, 7, date);
	if (ret)
		return ret;

	if ((date1[RV8803_SEC] & 0x7f) == bin2bcd(59)) {
		ret = rv8803_read_regs(rv8803->client, RV8803_SEC, 7, date2);
		if (ret)
			return ret;

		if ((date2[RV8803_SEC] & 0x7f) != bin2bcd(59))
			date = date2;
	}

	tm->tm_sec  = bcd2bin(date[RV8803_SEC] & 0x7f);
	tm->tm_min  = bcd2bin(date[RV8803_MIN] & 0x7f);
	tm->tm_hour = bcd2bin(date[RV8803_HOUR] & 0x3f);
	tm->tm_wday = ilog2(date[RV8803_WEEK] & 0x7f);
	tm->tm_mday = bcd2bin(date[RV8803_DAY] & 0x3f);
	tm->tm_mon  = bcd2bin(date[RV8803_MONTH] & 0x1f) - 1;
	tm->tm_year = bcd2bin(date[RV8803_YEAR]) + 100;

	return 0;
}

static int rv8803_set_time(struct device *dev, struct rtc_time *tm)
{
	struct rv8803_data *rv8803 = dev_get_drvdata(dev);
	u8 date[7];
	int ctrl, flags, ret;

	if ((tm->tm_year < 100) || (tm->tm_year > 199))
		return -EINVAL;

	ctrl = rv8803_read_reg(rv8803->client, RV8803_CTRL);
	if (ctrl < 0)
		return ctrl;

	/* Stop the clock */
	ret = rv8803_write_reg(rv8803->client, RV8803_CTRL,
			       ctrl | RV8803_CTRL_RESET);
	if (ret)
		return ret;

	date[RV8803_SEC]   = bin2bcd(tm->tm_sec);
	date[RV8803_MIN]   = bin2bcd(tm->tm_min);
	date[RV8803_HOUR]  = bin2bcd(tm->tm_hour);
	date[RV8803_WEEK]  = 1 << (tm->tm_wday);
	date[RV8803_DAY]   = bin2bcd(tm->tm_mday);
	date[RV8803_MONTH] = bin2bcd(tm->tm_mon + 1);
	date[RV8803_YEAR]  = bin2bcd(tm->tm_year - 100);

	ret = rv8803_write_regs(rv8803->client, RV8803_SEC, 7, date);
	if (ret)
		return ret;

	/* Restart the clock */
	ret = rv8803_write_reg(rv8803->client, RV8803_CTRL,
			       ctrl & ~RV8803_CTRL_RESET);
	if (ret)
		return ret;

	mutex_lock(&rv8803->flags_lock);

	flags = rv8803_read_reg(rv8803->client, RV8803_FLAG);
	if (flags < 0) {
		mutex_unlock(&rv8803->flags_lock);
		return flags;
	}

	ret = rv8803_write_reg(rv8803->client, RV8803_FLAG,
			       flags & ~RV8803_FLAG_V2F);

	mutex_unlock(&rv8803->flags_lock);

	return ret;
}

static int rv8803_get_alarm(struct device *dev, struct rtc_wkalrm *alrm)
{
	struct rv8803_data *rv8803 = dev_get_drvdata(dev);
	struct i2c_client *client = rv8803->client;
	u8 alarmvals[3];
	int flags, ret;

	ret = rv8803_read_regs(client, RV8803_ALARM_MIN, 3, alarmvals);
	if (ret)
		return ret;

	flags = rv8803_read_reg(client, RV8803_FLAG);
	if (flags < 0)
		return flags;

	alrm->time.tm_sec  = 0;
	alrm->time.tm_min  = bcd2bin(alarmvals[0] & 0x7f);
	alrm->time.tm_hour = bcd2bin(alarmvals[1] & 0x3f);
	alrm->time.tm_mday = bcd2bin(alarmvals[2] & 0x3f);

	alrm->enabled = !!(rv8803->ctrl & RV8803_CTRL_AIE);
	alrm->pending = (flags & RV8803_FLAG_AF) && alrm->enabled;

	return 0;
}

static int rv8803_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct rv8803_data *rv8803 = dev_get_drvdata(dev);
	u8 alarmvals[3];
	u8 ctrl[2];
	int ret, err;

	/* The alarm has no seconds, round up to nearest minute */
	if (alrm->time.tm_sec) {
		time64_t alarm_time = rtc_tm_to_time64(&alrm->time);

		alarm_time += 60 - alrm->time.tm_sec;
		rtc_time64_to_tm(alarm_time, &alrm->time);
	}

	mutex_lock(&rv8803->flags_lock);

	ret = rv8803_read_regs(client, RV8803_FLAG, 2, ctrl);
	if (ret) {
		mutex_unlock(&rv8803->flags_lock);
		return ret;
	}

	alarmvals[0] = bin2bcd(alrm->time.tm_min);
	alarmvals[1] = bin2bcd(alrm->time.tm_hour);
	alarmvals[2] = bin2bcd(alrm->time.tm_mday);

	if (rv8803->ctrl & (RV8803_CTRL_AIE | RV8803_CTRL_UIE)) {
		rv8803->ctrl &= ~(RV8803_CTRL_AIE | RV8803_CTRL_UIE);
		err = rv8803_write_reg(rv8803->client, RV8803_CTRL,
				       rv8803->ctrl);
		if (err) {
			mutex_unlock(&rv8803->flags_lock);
			return err;
		}
	}

	ctrl[1] &= ~RV8803_FLAG_AF;
	err = rv8803_write_reg(rv8803->client, RV8803_FLAG, ctrl[1]);
	mutex_unlock(&rv8803->flags_lock);
	if (err)
		return err;

	err = rv8803_write_regs(rv8803->client, RV8803_ALARM_MIN, 3, alarmvals);
	if (err)
		return err;

	if (alrm->enabled) {
		if (rv8803->rtc->uie_rtctimer.enabled)
			rv8803->ctrl |= RV8803_CTRL_UIE;
		if (rv8803->rtc->aie_timer.enabled)
			rv8803->ctrl |= RV8803_CTRL_AIE;

		err = rv8803_write_reg(rv8803->client, RV8803_CTRL,
				       rv8803->ctrl);
		if (err)
			return err;
	}

	return 0;
}

static int rv8803_alarm_irq_enable(struct device *dev, unsigned int enabled)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct rv8803_data *rv8803 = dev_get_drvdata(dev);
	int ctrl, flags, err;

	ctrl = rv8803->ctrl;

	if (enabled) {
		if (rv8803->rtc->uie_rtctimer.enabled)
			ctrl |= RV8803_CTRL_UIE;
		if (rv8803->rtc->aie_timer.enabled)
			ctrl |= RV8803_CTRL_AIE;
	} else {
		if (!rv8803->rtc->uie_rtctimer.enabled)
			ctrl &= ~RV8803_CTRL_UIE;
		if (!rv8803->rtc->aie_timer.enabled)
			ctrl &= ~RV8803_CTRL_AIE;
	}

	mutex_lock(&rv8803->flags_lock);
	flags = rv8803_read_reg(client, RV8803_FLAG);
	if (flags < 0) {
		mutex_unlock(&rv8803->flags_lock);
		return flags;
	}
	flags &= ~(RV8803_FLAG_AF | RV8803_FLAG_UF);
	err = rv8803_write_reg(client, RV8803_FLAG, flags);
	mutex_unlock(&rv8803->flags_lock);
	if (err)
		return err;

	if (ctrl != rv8803->ctrl) {
		rv8803->ctrl = ctrl;
		err = rv8803_write_reg(client, RV8803_CTRL, rv8803->ctrl);
		if (err)
			return err;
	}

	return 0;
}

static int rv8803_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct rv8803_data *rv8803 = dev_get_drvdata(dev);
	int flags, ret = 0;

	switch (cmd) {
	case RTC_VL_READ:
		flags = rv8803_read_reg(client, RV8803_FLAG);
		if (flags < 0)
			return flags;

		if (flags & RV8803_FLAG_V1F)
			dev_warn(&client->dev, "Voltage low, temperature compensation stopped.\n");

		if (flags & RV8803_FLAG_V2F)
			dev_warn(&client->dev, "Voltage low, data loss detected.\n");

		flags &= RV8803_FLAG_V1F | RV8803_FLAG_V2F;

		if (copy_to_user((void __user *)arg, &flags, sizeof(int)))
			return -EFAULT;

		return 0;

	case RTC_VL_CLR:
		mutex_lock(&rv8803->flags_lock);
		flags = rv8803_read_reg(client, RV8803_FLAG);
		if (flags < 0) {
			mutex_unlock(&rv8803->flags_lock);
			return flags;
		}

		flags &= ~(RV8803_FLAG_V1F | RV8803_FLAG_V2F);
		ret = rv8803_write_reg(client, RV8803_FLAG, flags);
		mutex_unlock(&rv8803->flags_lock);
		if (ret)
			return ret;

		return 0;

	default:
		return -ENOIOCTLCMD;
	}
}

static ssize_t rv8803_nvram_write(struct file *filp, struct kobject *kobj,
				  struct bin_attribute *attr,
				  char *buf, loff_t off, size_t count)
{
	struct device *dev = kobj_to_dev(kobj);
	struct i2c_client *client = to_i2c_client(dev);
	int ret;

	ret = rv8803_write_reg(client, RV8803_RAM, buf[0]);
	if (ret)
		return ret;

	return 1;
}

static ssize_t rv8803_nvram_read(struct file *filp, struct kobject *kobj,
				 struct bin_attribute *attr,
				 char *buf, loff_t off, size_t count)
{
	struct device *dev = kobj_to_dev(kobj);
	struct i2c_client *client = to_i2c_client(dev);
	int ret;

	ret = rv8803_read_reg(client, RV8803_RAM);
	if (ret < 0)
		return ret;

	buf[0] = ret;

	return 1;
}

static struct bin_attribute rv8803_nvram_attr = {
	.attr = {
		.name = "nvram",
		.mode = S_IRUGO | S_IWUSR,
	},
	.size = 1,
	.read = rv8803_nvram_read,
	.write = rv8803_nvram_write,
};

static struct rtc_class_ops rv8803_rtc_ops = {
	.read_time = rv8803_get_time,
	.set_time = rv8803_set_time,
	.ioctl = rv8803_ioctl,
};

static int rv8803_probe(struct i2c_client *client,
			const struct i2c_device_id *id)
{
	struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
	struct rv8803_data *rv8803;
	int err, flags;

	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
				     I2C_FUNC_SMBUS_I2C_BLOCK)) {
		dev_err(&adapter->dev, "doesn't support I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_I2C_BLOCK\n");
		return -EIO;
	}

	rv8803 = devm_kzalloc(&client->dev, sizeof(struct rv8803_data),
			      GFP_KERNEL);
	if (!rv8803)
		return -ENOMEM;

	mutex_init(&rv8803->flags_lock);
	rv8803->client = client;
	i2c_set_clientdata(client, rv8803);

	flags = rv8803_read_reg(client, RV8803_FLAG);
	if (flags < 0)
		return flags;

	if (flags & RV8803_FLAG_V1F)
		dev_warn(&client->dev, "Voltage low, temperature compensation stopped.\n");

	if (flags & RV8803_FLAG_V2F)
		dev_warn(&client->dev, "Voltage low, data loss detected.\n");

	if (flags & RV8803_FLAG_AF)
		dev_warn(&client->dev, "An alarm maybe have been missed.\n");

	if (client->irq > 0) {
		err = devm_request_threaded_irq(&client->dev, client->irq,
						NULL, rv8803_handle_irq,
						IRQF_TRIGGER_LOW | IRQF_ONESHOT,
						"rv8803", client);
		if (err) {
			dev_warn(&client->dev, "unable to request IRQ, alarms disabled\n");
			client->irq = 0;
		} else {
			rv8803_rtc_ops.read_alarm = rv8803_get_alarm;
			rv8803_rtc_ops.set_alarm = rv8803_set_alarm;
			rv8803_rtc_ops.alarm_irq_enable = rv8803_alarm_irq_enable;
		}
	}

	rv8803->rtc = devm_rtc_device_register(&client->dev, client->name,
					       &rv8803_rtc_ops, THIS_MODULE);
	if (IS_ERR(rv8803->rtc)) {
		dev_err(&client->dev, "unable to register the class device\n");
		return PTR_ERR(rv8803->rtc);
	}

	err = rv8803_write_reg(rv8803->client, RV8803_EXT, RV8803_EXT_WADA);
	if (err)
		return err;

	err = device_create_bin_file(&client->dev, &rv8803_nvram_attr);
	if (err)
		return err;

	rv8803->rtc->max_user_freq = 1;

	return 0;
}

static int rv8803_remove(struct i2c_client *client)
{
	device_remove_bin_file(&client->dev, &rv8803_nvram_attr);

	return 0;
}

static const struct i2c_device_id rv8803_id[] = {
	{ "rv8803", 0 },
	{ "rx8900", 0 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, rv8803_id);

static struct i2c_driver rv8803_driver = {
	.driver = {
		.name = "rtc-rv8803",
	},
	.probe		= rv8803_probe,
	.remove		= rv8803_remove,
	.id_table	= rv8803_id,
};
module_i2c_driver(rv8803_driver);

MODULE_AUTHOR("Alexandre Belloni <alexandre.belloni@free-electrons.com>");
MODULE_DESCRIPTION("Micro Crystal RV8803 RTC driver");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
1e3929ef AB	1	/*
	2	* RTC driver for the Micro Crystal RV8803
	3	*
	4	* Copyright (C) 2015 Micro Crystal SA
	5	*
	6	* Alexandre Belloni <alexandre.belloni@free-electrons.com>
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License version 2 as
	10	* published by the Free Software Foundation.
	11	*
	12	*/
	13
	14	#include <linux/bcd.h>
	15	#include <linux/bitops.h>
a1e98e09	16	#include <linux/log2.h>
1e3929ef AB	17	#include <linux/i2c.h>
	18	#include <linux/interrupt.h>
	19	#include <linux/kernel.h>
	20	#include <linux/module.h>
	21	#include <linux/rtc.h>
	22
d522649e BT	23	#define RV8803_I2C_TRY_COUNT 4
d522649e BT	24
1e3929ef AB	25	#define RV8803_SEC 0x00
	26	#define RV8803_MIN 0x01
	27	#define RV8803_HOUR 0x02
	28	#define RV8803_WEEK 0x03
	29	#define RV8803_DAY 0x04
	30	#define RV8803_MONTH 0x05
	31	#define RV8803_YEAR 0x06
	32	#define RV8803_RAM 0x07
	33	#define RV8803_ALARM_MIN 0x08
	34	#define RV8803_ALARM_HOUR 0x09
	35	#define RV8803_ALARM_WEEK_OR_DAY 0x0A
	36	#define RV8803_EXT 0x0D
	37	#define RV8803_FLAG 0x0E
	38	#define RV8803_CTRL 0x0F
	39
	40	#define RV8803_EXT_WADA BIT(6)
	41
	42	#define RV8803_FLAG_V1F BIT(0)
	43	#define RV8803_FLAG_V2F BIT(1)
	44	#define RV8803_FLAG_AF BIT(3)
	45	#define RV8803_FLAG_TF BIT(4)
	46	#define RV8803_FLAG_UF BIT(5)
	47
	48	#define RV8803_CTRL_RESET BIT(0)
	49
	50	#define RV8803_CTRL_EIE BIT(2)
	51	#define RV8803_CTRL_AIE BIT(3)
	52	#define RV8803_CTRL_TIE BIT(4)
	53	#define RV8803_CTRL_UIE BIT(5)
	54
	55	struct rv8803_data {
	56	struct i2c_client *client;
	57	struct rtc_device *rtc;
9d1fa4c3	58	struct mutex flags_lock;
1e3929ef AB	59	u8 ctrl;
	60	};
	61
d522649e BT	62	static int rv8803_read_reg(const struct i2c_client *client, u8 reg)
	63	{
	64	int try = RV8803_I2C_TRY_COUNT;
	65	s32 ret;
	66
	67	/*
	68	* There is a 61µs window during which the RTC does not acknowledge I2C
	69	* transfers. In that case, ensure that there are multiple attempts.
	70	*/
	71	do
	72	ret = i2c_smbus_read_byte_data(client, reg);
	73	while ((ret == -ENXIO \|\| ret == -EIO) && --try);
	74	if (ret < 0)
	75	dev_err(&client->dev, "Unable to read register 0x%02x\n", reg);
	76
	77	return ret;
	78	}
	79
	80	static int rv8803_read_regs(const struct i2c_client *client,
	81	u8 reg, u8 count, u8 *values)
	82	{
	83	int try = RV8803_I2C_TRY_COUNT;
	84	s32 ret;
	85
	86	do
	87	ret = i2c_smbus_read_i2c_block_data(client, reg, count, values);
	88	while ((ret == -ENXIO \|\| ret == -EIO) && --try);
	89	if (ret != count) {
	90	dev_err(&client->dev,
	91	"Unable to read registers 0x%02x..0x%02x\n",
	92	reg, reg + count - 1);
	93	return ret < 0 ? ret : -EIO;
	94	}
	95
	96	return 0;
	97	}
	98
	99	static int rv8803_write_reg(const struct i2c_client *client, u8 reg, u8 value)
	100	{
	101	int try = RV8803_I2C_TRY_COUNT;
	102	s32 ret;
	103
	104	do
	105	ret = i2c_smbus_write_byte_data(client, reg, value);
	106	while ((ret == -ENXIO \|\| ret == -EIO) && --try);
	107	if (ret)
	108	dev_err(&client->dev, "Unable to write register 0x%02x\n", reg);
	109
	110	return ret;
	111	}
	112
	113	static int rv8803_write_regs(const struct i2c_client *client,
	114	u8 reg, u8 count, const u8 *values)
	115	{
	116	int try = RV8803_I2C_TRY_COUNT;
	117	s32 ret;
	118
	119	do
	120	ret = i2c_smbus_write_i2c_block_data(client, reg, count,
	121	values);
	122	while ((ret == -ENXIO \|\| ret == -EIO) && --try);
	123	if (ret)
	124	dev_err(&client->dev,
	125	"Unable to write registers 0x%02x..0x%02x\n",
126	reg, reg + count - 1);
127
128	return ret;
129	}
130
1e3929ef AB	131	static irqreturn_t rv8803_handle_irq(int irq, void *dev_id)
	132	{
	133	struct i2c_client *client = dev_id;
	134	struct rv8803_data *rv8803 = i2c_get_clientdata(client);
	135	unsigned long events = 0;
d522649e	136	int flags;
1e3929ef	137
9d1fa4c3	138	mutex_lock(&rv8803->flags_lock);
1e3929ef	139
d522649e	140	flags = rv8803_read_reg(client, RV8803_FLAG);
1e3929ef	141	if (flags <= 0) {
9d1fa4c3	142	mutex_unlock(&rv8803->flags_lock);
1e3929ef AB	143	return IRQ_NONE;
	144	}
	145
	146	if (flags & RV8803_FLAG_V1F)
	147	dev_warn(&client->dev, "Voltage low, temperature compensation stopped.\n");
	148
	149	if (flags & RV8803_FLAG_V2F)
	150	dev_warn(&client->dev, "Voltage low, data loss detected.\n");
	151
	152	if (flags & RV8803_FLAG_TF) {
	153	flags &= ~RV8803_FLAG_TF;
	154	rv8803->ctrl &= ~RV8803_CTRL_TIE;
	155	events \|= RTC_PF;
	156	}
	157
	158	if (flags & RV8803_FLAG_AF) {
	159	flags &= ~RV8803_FLAG_AF;
	160	rv8803->ctrl &= ~RV8803_CTRL_AIE;
	161	events \|= RTC_AF;
	162	}
	163
	164	if (flags & RV8803_FLAG_UF) {
	165	flags &= ~RV8803_FLAG_UF;
	166	rv8803->ctrl &= ~RV8803_CTRL_UIE;
	167	events \|= RTC_UF;
	168	}
	169
	170	if (events) {
	171	rtc_update_irq(rv8803->rtc, 1, events);
d522649e BT	172	rv8803_write_reg(client, RV8803_FLAG, flags);
d522649e BT	173	rv8803_write_reg(rv8803->client, RV8803_CTRL, rv8803->ctrl);
1e3929ef AB	174	}
1e3929ef AB	175
9d1fa4c3	176	mutex_unlock(&rv8803->flags_lock);
1e3929ef AB	177
	178	return IRQ_HANDLED;
	179	}
	180
	181	static int rv8803_get_time(struct device dev, struct rtc_time tm)
	182	{
	183	struct rv8803_data *rv8803 = dev_get_drvdata(dev);
	184	u8 date1[7];
	185	u8 date2[7];
	186	u8 *date = date1;
	187	int ret, flags;
	188
d522649e	189	flags = rv8803_read_reg(rv8803->client, RV8803_FLAG);
1e3929ef AB	190	if (flags < 0)
	191	return flags;
	192
	193	if (flags & RV8803_FLAG_V2F) {
	194	dev_warn(dev, "Voltage low, data is invalid.\n");
	195	return -EINVAL;
	196	}
	197
d522649e BT	198	ret = rv8803_read_regs(rv8803->client, RV8803_SEC, 7, date);
	199	if (ret)
	200	return ret;
1e3929ef AB	201
1e3929ef AB	202	if ((date1[RV8803_SEC] & 0x7f) == bin2bcd(59)) {
d522649e BT	203	ret = rv8803_read_regs(rv8803->client, RV8803_SEC, 7, date2);
	204	if (ret)
	205	return ret;
1e3929ef AB	206
	207	if ((date2[RV8803_SEC] & 0x7f) != bin2bcd(59))
	208	date = date2;
	209	}
	210
	211	tm->tm_sec = bcd2bin(date[RV8803_SEC] & 0x7f);
	212	tm->tm_min = bcd2bin(date[RV8803_MIN] & 0x7f);
	213	tm->tm_hour = bcd2bin(date[RV8803_HOUR] & 0x3f);
a1e98e09	214	tm->tm_wday = ilog2(date[RV8803_WEEK] & 0x7f);
1e3929ef AB	215	tm->tm_mday = bcd2bin(date[RV8803_DAY] & 0x3f);
	216	tm->tm_mon = bcd2bin(date[RV8803_MONTH] & 0x1f) - 1;
	217	tm->tm_year = bcd2bin(date[RV8803_YEAR]) + 100;
	218
96acb25c	219	return 0;
1e3929ef AB	220	}
	221
	222	static int rv8803_set_time(struct device dev, struct rtc_time tm)
	223	{
	224	struct rv8803_data *rv8803 = dev_get_drvdata(dev);
	225	u8 date[7];
d3700b6b	226	int ctrl, flags, ret;
1e3929ef AB	227
	228	if ((tm->tm_year < 100) \|\| (tm->tm_year > 199))
	229	return -EINVAL;
	230
d3700b6b BT	231	ctrl = rv8803_read_reg(rv8803->client, RV8803_CTRL);
	232	if (ctrl < 0)
	233	return ctrl;
	234
	235	/* Stop the clock */
	236	ret = rv8803_write_reg(rv8803->client, RV8803_CTRL,
	237	ctrl \| RV8803_CTRL_RESET);
	238	if (ret)
	239	return ret;
	240
1e3929ef AB	241	date[RV8803_SEC] = bin2bcd(tm->tm_sec);
	242	date[RV8803_MIN] = bin2bcd(tm->tm_min);
	243	date[RV8803_HOUR] = bin2bcd(tm->tm_hour);
	244	date[RV8803_WEEK] = 1 << (tm->tm_wday);
	245	date[RV8803_DAY] = bin2bcd(tm->tm_mday);
	246	date[RV8803_MONTH] = bin2bcd(tm->tm_mon + 1);
	247	date[RV8803_YEAR] = bin2bcd(tm->tm_year - 100);
	248
d522649e BT	249	ret = rv8803_write_regs(rv8803->client, RV8803_SEC, 7, date);
d522649e BT	250	if (ret)
1e3929ef AB	251	return ret;
1e3929ef AB	252
d3700b6b BT	253	/* Restart the clock */
	254	ret = rv8803_write_reg(rv8803->client, RV8803_CTRL,
	255	ctrl & ~RV8803_CTRL_RESET);
	256	if (ret)
	257	return ret;
	258
9d1fa4c3	259	mutex_lock(&rv8803->flags_lock);
1e3929ef	260
d522649e	261	flags = rv8803_read_reg(rv8803->client, RV8803_FLAG);
1e3929ef	262	if (flags < 0) {
9d1fa4c3	263	mutex_unlock(&rv8803->flags_lock);
1e3929ef AB	264	return flags;
	265	}
	266
d522649e BT	267	ret = rv8803_write_reg(rv8803->client, RV8803_FLAG,
d522649e BT	268	flags & ~RV8803_FLAG_V2F);
1e3929ef	269
9d1fa4c3	270	mutex_unlock(&rv8803->flags_lock);
1e3929ef AB	271
	272	return ret;
	273	}
	274
	275	static int rv8803_get_alarm(struct device dev, struct rtc_wkalrm alrm)
	276	{
	277	struct rv8803_data *rv8803 = dev_get_drvdata(dev);
	278	struct i2c_client *client = rv8803->client;
	279	u8 alarmvals[3];
	280	int flags, ret;
	281
d522649e BT	282	ret = rv8803_read_regs(client, RV8803_ALARM_MIN, 3, alarmvals);
	283	if (ret)
	284	return ret;
1e3929ef	285
d522649e	286	flags = rv8803_read_reg(client, RV8803_FLAG);
1e3929ef AB	287	if (flags < 0)
	288	return flags;
	289
	290	alrm->time.tm_sec = 0;
	291	alrm->time.tm_min = bcd2bin(alarmvals[0] & 0x7f);
	292	alrm->time.tm_hour = bcd2bin(alarmvals[1] & 0x3f);
1e3929ef	293	alrm->time.tm_mday = bcd2bin(alarmvals[2] & 0x3f);
1e3929ef AB	294
	295	alrm->enabled = !!(rv8803->ctrl & RV8803_CTRL_AIE);
	296	alrm->pending = (flags & RV8803_FLAG_AF) && alrm->enabled;
	297
	298	return 0;
	299	}
	300
	301	static int rv8803_set_alarm(struct device dev, struct rtc_wkalrm alrm)
	302	{
	303	struct i2c_client *client = to_i2c_client(dev);
	304	struct rv8803_data *rv8803 = dev_get_drvdata(dev);
	305	u8 alarmvals[3];
	306	u8 ctrl[2];
	307	int ret, err;
1e3929ef AB	308
	309	/* The alarm has no seconds, round up to nearest minute */
	310	if (alrm->time.tm_sec) {
	311	time64_t alarm_time = rtc_tm_to_time64(&alrm->time);
	312
	313	alarm_time += 60 - alrm->time.tm_sec;
	314	rtc_time64_to_tm(alarm_time, &alrm->time);
	315	}
	316
9d1fa4c3	317	mutex_lock(&rv8803->flags_lock);
1e3929ef	318
d522649e BT	319	ret = rv8803_read_regs(client, RV8803_FLAG, 2, ctrl);
d522649e BT	320	if (ret) {
9d1fa4c3	321	mutex_unlock(&rv8803->flags_lock);
d522649e	322	return ret;
1e3929ef AB	323	}
	324
	325	alarmvals[0] = bin2bcd(alrm->time.tm_min);
	326	alarmvals[1] = bin2bcd(alrm->time.tm_hour);
	327	alarmvals[2] = bin2bcd(alrm->time.tm_mday);
	328
	329	if (rv8803->ctrl & (RV8803_CTRL_AIE \| RV8803_CTRL_UIE)) {
	330	rv8803->ctrl &= ~(RV8803_CTRL_AIE \| RV8803_CTRL_UIE);
d522649e BT	331	err = rv8803_write_reg(rv8803->client, RV8803_CTRL,
d522649e BT	332	rv8803->ctrl);
1e3929ef	333	if (err) {
9d1fa4c3	334	mutex_unlock(&rv8803->flags_lock);
1e3929ef AB	335	return err;
	336	}
	337	}
	338
	339	ctrl[1] &= ~RV8803_FLAG_AF;
d522649e	340	err = rv8803_write_reg(rv8803->client, RV8803_FLAG, ctrl[1]);
9d1fa4c3	341	mutex_unlock(&rv8803->flags_lock);
1e3929ef AB	342	if (err)
	343	return err;
	344
d522649e	345	err = rv8803_write_regs(rv8803->client, RV8803_ALARM_MIN, 3, alarmvals);
1e3929ef AB	346	if (err)
	347	return err;
	348
	349	if (alrm->enabled) {
	350	if (rv8803->rtc->uie_rtctimer.enabled)
	351	rv8803->ctrl \|= RV8803_CTRL_UIE;
	352	if (rv8803->rtc->aie_timer.enabled)
	353	rv8803->ctrl \|= RV8803_CTRL_AIE;
	354
d522649e BT	355	err = rv8803_write_reg(rv8803->client, RV8803_CTRL,
d522649e BT	356	rv8803->ctrl);
1e3929ef AB	357	if (err)
	358	return err;
	359	}
	360
	361	return 0;
	362	}
	363
	364	static int rv8803_alarm_irq_enable(struct device *dev, unsigned int enabled)
	365	{
	366	struct i2c_client *client = to_i2c_client(dev);
	367	struct rv8803_data *rv8803 = dev_get_drvdata(dev);
	368	int ctrl, flags, err;
1e3929ef AB	369
	370	ctrl = rv8803->ctrl;
	371
	372	if (enabled) {
	373	if (rv8803->rtc->uie_rtctimer.enabled)
	374	ctrl \|= RV8803_CTRL_UIE;
	375	if (rv8803->rtc->aie_timer.enabled)
	376	ctrl \|= RV8803_CTRL_AIE;
	377	} else {
	378	if (!rv8803->rtc->uie_rtctimer.enabled)
	379	ctrl &= ~RV8803_CTRL_UIE;
	380	if (!rv8803->rtc->aie_timer.enabled)
	381	ctrl &= ~RV8803_CTRL_AIE;
	382	}
	383
9d1fa4c3	384	mutex_lock(&rv8803->flags_lock);
d522649e	385	flags = rv8803_read_reg(client, RV8803_FLAG);
1e3929ef	386	if (flags < 0) {
9d1fa4c3	387	mutex_unlock(&rv8803->flags_lock);
1e3929ef AB	388	return flags;
	389	}
	390	flags &= ~(RV8803_FLAG_AF \| RV8803_FLAG_UF);
d522649e	391	err = rv8803_write_reg(client, RV8803_FLAG, flags);
9d1fa4c3	392	mutex_unlock(&rv8803->flags_lock);
1e3929ef AB	393	if (err)
	394	return err;
	395
	396	if (ctrl != rv8803->ctrl) {
	397	rv8803->ctrl = ctrl;
d522649e	398	err = rv8803_write_reg(client, RV8803_CTRL, rv8803->ctrl);
1e3929ef AB	399	if (err)
	400	return err;
	401	}
	402
	403	return 0;
	404	}
	405
	406	static int rv8803_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
	407	{
	408	struct i2c_client *client = to_i2c_client(dev);
	409	struct rv8803_data *rv8803 = dev_get_drvdata(dev);
	410	int flags, ret = 0;
1e3929ef AB	411
	412	switch (cmd) {
	413	case RTC_VL_READ:
d522649e	414	flags = rv8803_read_reg(client, RV8803_FLAG);
1e3929ef AB	415	if (flags < 0)
	416	return flags;
	417
	418	if (flags & RV8803_FLAG_V1F)
	419	dev_warn(&client->dev, "Voltage low, temperature compensation stopped.\n");
	420
	421	if (flags & RV8803_FLAG_V2F)
	422	dev_warn(&client->dev, "Voltage low, data loss detected.\n");
	423
	424	flags &= RV8803_FLAG_V1F \| RV8803_FLAG_V2F;
	425
	426	if (copy_to_user((void __user *)arg, &flags, sizeof(int)))
	427	return -EFAULT;
	428
	429	return 0;
	430
	431	case RTC_VL_CLR:
9d1fa4c3	432	mutex_lock(&rv8803->flags_lock);
d522649e	433	flags = rv8803_read_reg(client, RV8803_FLAG);
1e3929ef	434	if (flags < 0) {
9d1fa4c3	435	mutex_unlock(&rv8803->flags_lock);
1e3929ef AB	436	return flags;
	437	}
	438
	439	flags &= ~(RV8803_FLAG_V1F \| RV8803_FLAG_V2F);
d522649e	440	ret = rv8803_write_reg(client, RV8803_FLAG, flags);
9d1fa4c3	441	mutex_unlock(&rv8803->flags_lock);
d522649e	442	if (ret)
1e3929ef AB	443	return ret;
	444
	445	return 0;
	446
	447	default:
	448	return -ENOIOCTLCMD;
	449	}
	450	}
	451
	452	static ssize_t rv8803_nvram_write(struct file filp, struct kobject kobj,
	453	struct bin_attribute *attr,
	454	char *buf, loff_t off, size_t count)
	455	{
	456	struct device *dev = kobj_to_dev(kobj);
	457	struct i2c_client *client = to_i2c_client(dev);
	458	int ret;
	459
d522649e BT	460	ret = rv8803_write_reg(client, RV8803_RAM, buf[0]);
d522649e BT	461	if (ret)
1e3929ef AB	462	return ret;
	463
	464	return 1;
	465	}
	466
	467	static ssize_t rv8803_nvram_read(struct file filp, struct kobject kobj,
	468	struct bin_attribute *attr,
	469	char *buf, loff_t off, size_t count)
	470	{
	471	struct device *dev = kobj_to_dev(kobj);
	472	struct i2c_client *client = to_i2c_client(dev);
	473	int ret;
	474
d522649e	475	ret = rv8803_read_reg(client, RV8803_RAM);
1e3929ef AB	476	if (ret < 0)
	477	return ret;
	478
	479	buf[0] = ret;
	480
	481	return 1;
	482	}
	483
	484	static struct bin_attribute rv8803_nvram_attr = {
	485	.attr = {
	486	.name = "nvram",
	487	.mode = S_IRUGO \| S_IWUSR,
	488	},
	489	.size = 1,
	490	.read = rv8803_nvram_read,
	491	.write = rv8803_nvram_write,
	492	};
	493
	494	static struct rtc_class_ops rv8803_rtc_ops = {
	495	.read_time = rv8803_get_time,
	496	.set_time = rv8803_set_time,
	497	.ioctl = rv8803_ioctl,
	498	};
	499
	500	static int rv8803_probe(struct i2c_client *client,
	501	const struct i2c_device_id *id)
	502	{
	503	struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
	504	struct rv8803_data *rv8803;
d522649e	505	int err, flags;
1e3929ef AB	506
	507	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA \|
	508	I2C_FUNC_SMBUS_I2C_BLOCK)) {
	509	dev_err(&adapter->dev, "doesn't support I2C_FUNC_SMBUS_BYTE_DATA \| I2C_FUNC_SMBUS_I2C_BLOCK\n");
	510	return -EIO;
	511	}
	512
	513	rv8803 = devm_kzalloc(&client->dev, sizeof(struct rv8803_data),
	514	GFP_KERNEL);
	515	if (!rv8803)
	516	return -ENOMEM;
	517
9d1fa4c3	518	mutex_init(&rv8803->flags_lock);
1e3929ef AB	519	rv8803->client = client;
	520	i2c_set_clientdata(client, rv8803);
	521
d522649e	522	flags = rv8803_read_reg(client, RV8803_FLAG);
1e3929ef AB	523	if (flags < 0)
	524	return flags;
	525
	526	if (flags & RV8803_FLAG_V1F)
	527	dev_warn(&client->dev, "Voltage low, temperature compensation stopped.\n");
	528
	529	if (flags & RV8803_FLAG_V2F)
	530	dev_warn(&client->dev, "Voltage low, data loss detected.\n");
	531
	532	if (flags & RV8803_FLAG_AF)
	533	dev_warn(&client->dev, "An alarm maybe have been missed.\n");
	534
	535	if (client->irq > 0) {
	536	err = devm_request_threaded_irq(&client->dev, client->irq,
	537	NULL, rv8803_handle_irq,
	538	IRQF_TRIGGER_LOW \| IRQF_ONESHOT,
	539	"rv8803", client);
	540	if (err) {
	541	dev_warn(&client->dev, "unable to request IRQ, alarms disabled\n");
	542	client->irq = 0;
	543	} else {
	544	rv8803_rtc_ops.read_alarm = rv8803_get_alarm;
	545	rv8803_rtc_ops.set_alarm = rv8803_set_alarm;
	546	rv8803_rtc_ops.alarm_irq_enable = rv8803_alarm_irq_enable;
	547	}
	548	}
	549
	550	rv8803->rtc = devm_rtc_device_register(&client->dev, client->name,
	551	&rv8803_rtc_ops, THIS_MODULE);
	552	if (IS_ERR(rv8803->rtc)) {
	553	dev_err(&client->dev, "unable to register the class device\n");
	554	return PTR_ERR(rv8803->rtc);
	555	}
	556
d522649e	557	err = rv8803_write_reg(rv8803->client, RV8803_EXT, RV8803_EXT_WADA);
1e3929ef AB	558	if (err)
	559	return err;
	560
	561	err = device_create_bin_file(&client->dev, &rv8803_nvram_attr);
	562	if (err)
	563	return err;
	564
	565	rv8803->rtc->max_user_freq = 1;
	566
	567	return 0;
	568	}
	569
	570	static int rv8803_remove(struct i2c_client *client)
	571	{
	572	device_remove_bin_file(&client->dev, &rv8803_nvram_attr);
	573
	574	return 0;
	575	}
	576
	577	static const struct i2c_device_id rv8803_id[] = {
	578	{ "rv8803", 0 },
78ef5f2d	579	{ "rx8900", 0 },
1e3929ef AB	580	{ }
	581	};
	582	MODULE_DEVICE_TABLE(i2c, rv8803_id);
	583
	584	static struct i2c_driver rv8803_driver = {
	585	.driver = {
	586	.name = "rtc-rv8803",
	587	},
	588	.probe = rv8803_probe,
	589	.remove = rv8803_remove,
	590	.id_table = rv8803_id,
	591	};
	592	module_i2c_driver(rv8803_driver);
	593
	594	MODULE_AUTHOR("Alexandre Belloni <alexandre.belloni@free-electrons.com>");
	595	MODULE_DESCRIPTION("Micro Crystal RV8803 RTC driver");
	596	MODULE_LICENSE("GPL v2");