[mirror_ubuntu-artful-kernel.git] / drivers / rtc / rtc-s35390a.c

/*
 * Seiko Instruments S-35390A RTC Driver
 *
 * Copyright (c) 2007 Byron Bradley
 *
 * 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/module.h>
#include <linux/rtc.h>
#include <linux/i2c.h>
#include <linux/bitrev.h>
#include <linux/bcd.h>
#include <linux/slab.h>
#include <linux/delay.h>

#define S35390A_CMD_STATUS1	0
#define S35390A_CMD_STATUS2	1
#define S35390A_CMD_TIME1	2
#define S35390A_CMD_TIME2	3
#define S35390A_CMD_INT2_REG1	5

#define S35390A_BYTE_YEAR	0
#define S35390A_BYTE_MONTH	1
#define S35390A_BYTE_DAY	2
#define S35390A_BYTE_WDAY	3
#define S35390A_BYTE_HOURS	4
#define S35390A_BYTE_MINS	5
#define S35390A_BYTE_SECS	6

#define S35390A_ALRM_BYTE_WDAY	0
#define S35390A_ALRM_BYTE_HOURS	1
#define S35390A_ALRM_BYTE_MINS	2

/* flags for STATUS1 */
#define S35390A_FLAG_POC	0x01
#define S35390A_FLAG_BLD	0x02
#define S35390A_FLAG_INT2	0x04
#define S35390A_FLAG_24H	0x40
#define S35390A_FLAG_RESET	0x80

/* flag for STATUS2 */
#define S35390A_FLAG_TEST	0x01

#define S35390A_INT2_MODE_MASK		0xF0

#define S35390A_INT2_MODE_NOINTR	0x00
#define S35390A_INT2_MODE_FREQ		0x10
#define S35390A_INT2_MODE_ALARM		0x40
#define S35390A_INT2_MODE_PMIN_EDG	0x20

static const struct i2c_device_id s35390a_id[] = {
	{ "s35390a", 0 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, s35390a_id);

static const struct of_device_id s35390a_of_match[] = {
	{ .compatible = "s35390a" },
	{ .compatible = "sii,s35390a" },
	{ }
};
MODULE_DEVICE_TABLE(of, s35390a_of_match);

struct s35390a {
	struct i2c_client *client[8];
	struct rtc_device *rtc;
	int twentyfourhour;
};

static int s35390a_set_reg(struct s35390a *s35390a, int reg, char *buf, int len)
{
	struct i2c_client *client = s35390a->client[reg];
	struct i2c_msg msg[] = {
		{
			.addr = client->addr,
			.len = len,
			.buf = buf
		},
	};

	if ((i2c_transfer(client->adapter, msg, 1)) != 1)
		return -EIO;

	return 0;
}

static int s35390a_get_reg(struct s35390a *s35390a, int reg, char *buf, int len)
{
	struct i2c_client *client = s35390a->client[reg];
	struct i2c_msg msg[] = {
		{
			.addr = client->addr,
			.flags = I2C_M_RD,
			.len = len,
			.buf = buf
		},
	};

	if ((i2c_transfer(client->adapter, msg, 1)) != 1)
		return -EIO;

	return 0;
}

/*
 * Returns <0 on error, 0 if rtc is setup fine and 1 if the chip was reset.
 * To keep the information if an irq is pending, pass the value read from
 * STATUS1 to the caller.
 */
static int s35390a_reset(struct s35390a *s35390a, char *status1)
{
	char buf;
	int ret;
	unsigned initcount = 0;

	ret = s35390a_get_reg(s35390a, S35390A_CMD_STATUS1, status1, 1);
	if (ret < 0)
		return ret;

	if (*status1 & S35390A_FLAG_POC)
		/*
		 * Do not communicate for 0.5 seconds since the power-on
		 * detection circuit is in operation.
		 */
		msleep(500);
	else if (!(*status1 & S35390A_FLAG_BLD))
		/*
		 * If both POC and BLD are unset everything is fine.
		 */
		return 0;

	/*
	 * At least one of POC and BLD are set, so reinitialise chip. Keeping
	 * this information in the hardware to know later that the time isn't
	 * valid is unfortunately not possible because POC and BLD are cleared
	 * on read. So the reset is best done now.
	 *
	 * The 24H bit is kept over reset, so set it already here.
	 */
initialize:
	*status1 = S35390A_FLAG_24H;
	buf = S35390A_FLAG_RESET | S35390A_FLAG_24H;
	ret = s35390a_set_reg(s35390a, S35390A_CMD_STATUS1, &buf, 1);

	if (ret < 0)
		return ret;

	ret = s35390a_get_reg(s35390a, S35390A_CMD_STATUS1, &buf, 1);
	if (ret < 0)
		return ret;

	if (buf & (S35390A_FLAG_POC | S35390A_FLAG_BLD)) {
		/* Try up to five times to reset the chip */
		if (initcount < 5) {
			++initcount;
			goto initialize;
		} else
			return -EIO;
	}

	return 1;
}

static int s35390a_disable_test_mode(struct s35390a *s35390a)
{
	char buf[1];

	if (s35390a_get_reg(s35390a, S35390A_CMD_STATUS2, buf, sizeof(buf)) < 0)
		return -EIO;

	if (!(buf[0] & S35390A_FLAG_TEST))
		return 0;

	buf[0] &= ~S35390A_FLAG_TEST;
	return s35390a_set_reg(s35390a, S35390A_CMD_STATUS2, buf, sizeof(buf));
}

static char s35390a_hr2reg(struct s35390a *s35390a, int hour)
{
	if (s35390a->twentyfourhour)
		return bin2bcd(hour);

	if (hour < 12)
		return bin2bcd(hour);

	return 0x40 | bin2bcd(hour - 12);
}

static int s35390a_reg2hr(struct s35390a *s35390a, char reg)
{
	unsigned hour;

	if (s35390a->twentyfourhour)
		return bcd2bin(reg & 0x3f);

	hour = bcd2bin(reg & 0x3f);
	if (reg & 0x40)
		hour += 12;

	return hour;
}

static int s35390a_set_datetime(struct i2c_client *client, struct rtc_time *tm)
{
	struct s35390a	*s35390a = i2c_get_clientdata(client);
	int i, err;
	char buf[7];

	dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d mday=%d, "
		"mon=%d, year=%d, wday=%d\n", __func__, tm->tm_sec,
		tm->tm_min, tm->tm_hour, tm->tm_mday, tm->tm_mon, tm->tm_year,
		tm->tm_wday);

	buf[S35390A_BYTE_YEAR] = bin2bcd(tm->tm_year - 100);
	buf[S35390A_BYTE_MONTH] = bin2bcd(tm->tm_mon + 1);
	buf[S35390A_BYTE_DAY] = bin2bcd(tm->tm_mday);
	buf[S35390A_BYTE_WDAY] = bin2bcd(tm->tm_wday);
	buf[S35390A_BYTE_HOURS] = s35390a_hr2reg(s35390a, tm->tm_hour);
	buf[S35390A_BYTE_MINS] = bin2bcd(tm->tm_min);
	buf[S35390A_BYTE_SECS] = bin2bcd(tm->tm_sec);

	/* This chip expects the bits of each byte to be in reverse order */
	for (i = 0; i < 7; ++i)
		buf[i] = bitrev8(buf[i]);

	err = s35390a_set_reg(s35390a, S35390A_CMD_TIME1, buf, sizeof(buf));

	return err;
}

static int s35390a_get_datetime(struct i2c_client *client, struct rtc_time *tm)
{
	struct s35390a *s35390a = i2c_get_clientdata(client);
	char buf[7];
	int i, err;

	err = s35390a_get_reg(s35390a, S35390A_CMD_TIME1, buf, sizeof(buf));
	if (err < 0)
		return err;

	/* This chip returns the bits of each byte in reverse order */
	for (i = 0; i < 7; ++i)
		buf[i] = bitrev8(buf[i]);

	tm->tm_sec = bcd2bin(buf[S35390A_BYTE_SECS]);
	tm->tm_min = bcd2bin(buf[S35390A_BYTE_MINS]);
	tm->tm_hour = s35390a_reg2hr(s35390a, buf[S35390A_BYTE_HOURS]);
	tm->tm_wday = bcd2bin(buf[S35390A_BYTE_WDAY]);
	tm->tm_mday = bcd2bin(buf[S35390A_BYTE_DAY]);
	tm->tm_mon = bcd2bin(buf[S35390A_BYTE_MONTH]) - 1;
	tm->tm_year = bcd2bin(buf[S35390A_BYTE_YEAR]) + 100;

	dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d, mday=%d, "
		"mon=%d, year=%d, wday=%d\n", __func__, tm->tm_sec,
		tm->tm_min, tm->tm_hour, tm->tm_mday, tm->tm_mon, tm->tm_year,
		tm->tm_wday);

	return rtc_valid_tm(tm);
}

static int s35390a_set_alarm(struct i2c_client *client, struct rtc_wkalrm *alm)
{
	struct s35390a *s35390a = i2c_get_clientdata(client);
	char buf[3], sts = 0;
	int err, i;

	dev_dbg(&client->dev, "%s: alm is secs=%d, mins=%d, hours=%d mday=%d, "\
		"mon=%d, year=%d, wday=%d\n", __func__, alm->time.tm_sec,
		alm->time.tm_min, alm->time.tm_hour, alm->time.tm_mday,
		alm->time.tm_mon, alm->time.tm_year, alm->time.tm_wday);

	/* disable interrupt (which deasserts the irq line) */
	err = s35390a_set_reg(s35390a, S35390A_CMD_STATUS2, &sts, sizeof(sts));
	if (err < 0)
		return err;

	/* clear pending interrupt (in STATUS1 only), if any */
	err = s35390a_get_reg(s35390a, S35390A_CMD_STATUS1, &sts, sizeof(sts));
	if (err < 0)
		return err;

	if (alm->enabled)
		sts = S35390A_INT2_MODE_ALARM;
	else
		sts = S35390A_INT2_MODE_NOINTR;

	/* This chip expects the bits of each byte to be in reverse order */
	sts = bitrev8(sts);

	/* set interupt mode*/
	err = s35390a_set_reg(s35390a, S35390A_CMD_STATUS2, &sts, sizeof(sts));
	if (err < 0)
		return err;

	if (alm->time.tm_wday != -1)
		buf[S35390A_ALRM_BYTE_WDAY] = bin2bcd(alm->time.tm_wday) | 0x80;
	else
		buf[S35390A_ALRM_BYTE_WDAY] = 0;

	buf[S35390A_ALRM_BYTE_HOURS] = s35390a_hr2reg(s35390a,
			alm->time.tm_hour) | 0x80;
	buf[S35390A_ALRM_BYTE_MINS] = bin2bcd(alm->time.tm_min) | 0x80;

	if (alm->time.tm_hour >= 12)
		buf[S35390A_ALRM_BYTE_HOURS] |= 0x40;

	for (i = 0; i < 3; ++i)
		buf[i] = bitrev8(buf[i]);

	err = s35390a_set_reg(s35390a, S35390A_CMD_INT2_REG1, buf,
								sizeof(buf));

	return err;
}

static int s35390a_read_alarm(struct i2c_client *client, struct rtc_wkalrm *alm)
{
	struct s35390a *s35390a = i2c_get_clientdata(client);
	char buf[3], sts;
	int i, err;

	err = s35390a_get_reg(s35390a, S35390A_CMD_STATUS2, &sts, sizeof(sts));
	if (err < 0)
		return err;

	if ((bitrev8(sts) & S35390A_INT2_MODE_MASK) != S35390A_INT2_MODE_ALARM) {
		/*
		 * When the alarm isn't enabled, the register to configure
		 * the alarm time isn't accessible.
		 */
		alm->enabled = 0;
		return 0;
	} else {
		alm->enabled = 1;
	}

	err = s35390a_get_reg(s35390a, S35390A_CMD_INT2_REG1, buf, sizeof(buf));
	if (err < 0)
		return err;

	/* This chip returns the bits of each byte in reverse order */
	for (i = 0; i < 3; ++i)
		buf[i] = bitrev8(buf[i]);

	/*
	 * B0 of the three matching registers is an enable flag. Iff it is set
	 * the configured value is used for matching.
	 */
	if (buf[S35390A_ALRM_BYTE_WDAY] & 0x80)
		alm->time.tm_wday =
			bcd2bin(buf[S35390A_ALRM_BYTE_WDAY] & ~0x80);

	if (buf[S35390A_ALRM_BYTE_HOURS] & 0x80)
		alm->time.tm_hour =
			s35390a_reg2hr(s35390a,
				       buf[S35390A_ALRM_BYTE_HOURS] & ~0x80);

	if (buf[S35390A_ALRM_BYTE_MINS] & 0x80)
		alm->time.tm_min = bcd2bin(buf[S35390A_ALRM_BYTE_MINS] & ~0x80);

	/* alarm triggers always at s=0 */
	alm->time.tm_sec = 0;

	dev_dbg(&client->dev, "%s: alm is mins=%d, hours=%d, wday=%d\n",
			__func__, alm->time.tm_min, alm->time.tm_hour,
			alm->time.tm_wday);

	return 0;
}

static int s35390a_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
{
	return s35390a_read_alarm(to_i2c_client(dev), alm);
}

static int s35390a_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
{
	return s35390a_set_alarm(to_i2c_client(dev), alm);
}

static int s35390a_rtc_read_time(struct device *dev, struct rtc_time *tm)
{
	return s35390a_get_datetime(to_i2c_client(dev), tm);
}

static int s35390a_rtc_set_time(struct device *dev, struct rtc_time *tm)
{
	return s35390a_set_datetime(to_i2c_client(dev), tm);
}

static const struct rtc_class_ops s35390a_rtc_ops = {
	.read_time	= s35390a_rtc_read_time,
	.set_time	= s35390a_rtc_set_time,
	.set_alarm	= s35390a_rtc_set_alarm,
	.read_alarm	= s35390a_rtc_read_alarm,

};

static struct i2c_driver s35390a_driver;

static int s35390a_probe(struct i2c_client *client,
			 const struct i2c_device_id *id)
{
	int err, err_reset;
	unsigned int i;
	struct s35390a *s35390a;
	struct rtc_time tm;
	char buf, status1;

	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
		err = -ENODEV;
		goto exit;
	}

	s35390a = devm_kzalloc(&client->dev, sizeof(struct s35390a),
				GFP_KERNEL);
	if (!s35390a) {
		err = -ENOMEM;
		goto exit;
	}

	s35390a->client[0] = client;
	i2c_set_clientdata(client, s35390a);

	/* This chip uses multiple addresses, use dummy devices for them */
	for (i = 1; i < 8; ++i) {
		s35390a->client[i] = i2c_new_dummy(client->adapter,
					client->addr + i);
		if (!s35390a->client[i]) {
			dev_err(&client->dev, "Address %02x unavailable\n",
						client->addr + i);
			err = -EBUSY;
			goto exit_dummy;
		}
	}

	err_reset = s35390a_reset(s35390a, &status1);
	if (err_reset < 0) {
		err = err_reset;
		dev_err(&client->dev, "error resetting chip\n");
		goto exit_dummy;
	}

	if (status1 & S35390A_FLAG_24H)
		s35390a->twentyfourhour = 1;
	else
		s35390a->twentyfourhour = 0;

	if (status1 & S35390A_FLAG_INT2) {
		/* disable alarm (and maybe test mode) */
		buf = 0;
		err = s35390a_set_reg(s35390a, S35390A_CMD_STATUS2, &buf, 1);
		if (err < 0) {
			dev_err(&client->dev, "error disabling alarm");
			goto exit_dummy;
		}
	} else {
		err = s35390a_disable_test_mode(s35390a);
		if (err < 0) {
			dev_err(&client->dev, "error disabling test mode\n");
			goto exit_dummy;
		}
	}

	if (err_reset > 0 || s35390a_get_datetime(client, &tm) < 0)
		dev_warn(&client->dev, "clock needs to be set\n");

	device_set_wakeup_capable(&client->dev, 1);

	s35390a->rtc = devm_rtc_device_register(&client->dev,
					s35390a_driver.driver.name,
					&s35390a_rtc_ops, THIS_MODULE);

	if (IS_ERR(s35390a->rtc)) {
		err = PTR_ERR(s35390a->rtc);
		goto exit_dummy;
	}

	if (status1 & S35390A_FLAG_INT2)
		rtc_update_irq(s35390a->rtc, 1, RTC_AF);

	return 0;

exit_dummy:
	for (i = 1; i < 8; ++i)
		if (s35390a->client[i])
			i2c_unregister_device(s35390a->client[i]);

exit:
	return err;
}

static int s35390a_remove(struct i2c_client *client)
{
	unsigned int i;
	struct s35390a *s35390a = i2c_get_clientdata(client);

	for (i = 1; i < 8; ++i)
		if (s35390a->client[i])
			i2c_unregister_device(s35390a->client[i]);

	return 0;
}

static struct i2c_driver s35390a_driver = {
	.driver		= {
		.name	= "rtc-s35390a",
		.of_match_table = of_match_ptr(s35390a_of_match),
	},
	.probe		= s35390a_probe,
	.remove		= s35390a_remove,
	.id_table	= s35390a_id,
};

module_i2c_driver(s35390a_driver);

MODULE_AUTHOR("Byron Bradley <byron.bbradley@gmail.com>");
MODULE_DESCRIPTION("S35390A RTC driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
c46288b0 BB	1	/*
	2	* Seiko Instruments S-35390A RTC Driver
	3	*
	4	* Copyright (c) 2007 Byron Bradley
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public License
	8	* as published by the Free Software Foundation; either version
	9	* 2 of the License, or (at your option) any later version.
	10	*/
	11
	12	#include <linux/module.h>
	13	#include <linux/rtc.h>
	14	#include <linux/i2c.h>
	15	#include <linux/bitrev.h>
	16	#include <linux/bcd.h>
	17	#include <linux/slab.h>
8e6583f1	18	#include <linux/delay.h>
c46288b0 BB	19
	20	#define S35390A_CMD_STATUS1 0
	21	#define S35390A_CMD_STATUS2 1
	22	#define S35390A_CMD_TIME1 2
542dd33a ML	23	#define S35390A_CMD_TIME2 3
542dd33a ML	24	#define S35390A_CMD_INT2_REG1 5
c46288b0 BB	25
	26	#define S35390A_BYTE_YEAR 0
	27	#define S35390A_BYTE_MONTH 1
	28	#define S35390A_BYTE_DAY 2
	29	#define S35390A_BYTE_WDAY 3
	30	#define S35390A_BYTE_HOURS 4
	31	#define S35390A_BYTE_MINS 5
	32	#define S35390A_BYTE_SECS 6
	33
542dd33a ML	34	#define S35390A_ALRM_BYTE_WDAY 0
	35	#define S35390A_ALRM_BYTE_HOURS 1
	36	#define S35390A_ALRM_BYTE_MINS 2
	37
3bd32722	38	/* flags for STATUS1 */
c46288b0 BB	39	#define S35390A_FLAG_POC 0x01
c46288b0 BB	40	#define S35390A_FLAG_BLD 0x02
3bd32722	41	#define S35390A_FLAG_INT2 0x04
c46288b0 BB	42	#define S35390A_FLAG_24H 0x40
c46288b0 BB	43	#define S35390A_FLAG_RESET 0x80
3bd32722 UKK	44
3bd32722 UKK	45	/* flag for STATUS2 */
c46288b0 BB	46	#define S35390A_FLAG_TEST 0x01
c46288b0 BB	47
542dd33a ML	48	#define S35390A_INT2_MODE_MASK 0xF0
	49
	50	#define S35390A_INT2_MODE_NOINTR 0x00
	51	#define S35390A_INT2_MODE_FREQ 0x10
	52	#define S35390A_INT2_MODE_ALARM 0x40
	53	#define S35390A_INT2_MODE_PMIN_EDG 0x20
	54
3760f736 JD	55	static const struct i2c_device_id s35390a_id[] = {
	56	{ "s35390a", 0 },
	57	{ }
	58	};
	59	MODULE_DEVICE_TABLE(i2c, s35390a_id);
	60
21f27432 JMC	61	static const struct of_device_id s35390a_of_match[] = {
	62	{ .compatible = "s35390a" },
	63	{ .compatible = "sii,s35390a" },
	64	{ }
	65	};
	66	MODULE_DEVICE_TABLE(of, s35390a_of_match);
	67
c46288b0 BB	68	struct s35390a {
	69	struct i2c_client *client[8];
	70	struct rtc_device *rtc;
	71	int twentyfourhour;
	72	};
	73
	74	static int s35390a_set_reg(struct s35390a s35390a, int reg, char buf, int len)
	75	{
	76	struct i2c_client *client = s35390a->client[reg];
	77	struct i2c_msg msg[] = {
65659f63 S	78	{
	79	.addr = client->addr,
	80	.len = len,
	81	.buf = buf
	82	},
c46288b0 BB	83	};
	84
	85	if ((i2c_transfer(client->adapter, msg, 1)) != 1)
	86	return -EIO;
	87
	88	return 0;
	89	}
	90
	91	static int s35390a_get_reg(struct s35390a s35390a, int reg, char buf, int len)
	92	{
	93	struct i2c_client *client = s35390a->client[reg];
	94	struct i2c_msg msg[] = {
65659f63 S	95	{
	96	.addr = client->addr,
	97	.flags = I2C_M_RD,
	98	.len = len,
	99	.buf = buf
	100	},
c46288b0 BB	101	};
	102
	103	if ((i2c_transfer(client->adapter, msg, 1)) != 1)
	104	return -EIO;
	105
	106	return 0;
	107	}
	108
8e6583f1 UKK	109	/*
	110	* Returns <0 on error, 0 if rtc is setup fine and 1 if the chip was reset.
	111	* To keep the information if an irq is pending, pass the value read from
	112	* STATUS1 to the caller.
	113	*/
	114	static int s35390a_reset(struct s35390a s35390a, char status1)
c46288b0	115	{
8e6583f1 UKK	116	char buf;
	117	int ret;
	118	unsigned initcount = 0;
c46288b0	119
8e6583f1 UKK	120	ret = s35390a_get_reg(s35390a, S35390A_CMD_STATUS1, status1, 1);
	121	if (ret < 0)
	122	return ret;
c46288b0	123
8e6583f1 UKK	124	if (*status1 & S35390A_FLAG_POC)
	125	/*
	126	* Do not communicate for 0.5 seconds since the power-on
	127	* detection circuit is in operation.
	128	*/
	129	msleep(500);
	130	else if (!(*status1 & S35390A_FLAG_BLD))
	131	/*
	132	* If both POC and BLD are unset everything is fine.
	133	*/
c46288b0 BB	134	return 0;
c46288b0 BB	135
8e6583f1 UKK	136	/*
	137	* At least one of POC and BLD are set, so reinitialise chip. Keeping
	138	* this information in the hardware to know later that the time isn't
	139	* valid is unfortunately not possible because POC and BLD are cleared
	140	* on read. So the reset is best done now.
	141	*
	142	* The 24H bit is kept over reset, so set it already here.
	143	*/
	144	initialize:
	145	*status1 = S35390A_FLAG_24H;
	146	buf = S35390A_FLAG_RESET \| S35390A_FLAG_24H;
	147	ret = s35390a_set_reg(s35390a, S35390A_CMD_STATUS1, &buf, 1);
	148
	149	if (ret < 0)
	150	return ret;
	151
	152	ret = s35390a_get_reg(s35390a, S35390A_CMD_STATUS1, &buf, 1);
	153	if (ret < 0)
	154	return ret;
	155
	156	if (buf & (S35390A_FLAG_POC \| S35390A_FLAG_BLD)) {
	157	/* Try up to five times to reset the chip */
	158	if (initcount < 5) {
	159	++initcount;
	160	goto initialize;
	161	} else
	162	return -EIO;
	163	}
	164
	165	return 1;
c46288b0 BB	166	}
	167
	168	static int s35390a_disable_test_mode(struct s35390a *s35390a)
	169	{
	170	char buf[1];
	171
	172	if (s35390a_get_reg(s35390a, S35390A_CMD_STATUS2, buf, sizeof(buf)) < 0)
	173	return -EIO;
	174
	175	if (!(buf[0] & S35390A_FLAG_TEST))
	176	return 0;
	177
	178	buf[0] &= ~S35390A_FLAG_TEST;
	179	return s35390a_set_reg(s35390a, S35390A_CMD_STATUS2, buf, sizeof(buf));
	180	}
	181
	182	static char s35390a_hr2reg(struct s35390a *s35390a, int hour)
	183	{
	184	if (s35390a->twentyfourhour)
fe20ba70	185	return bin2bcd(hour);
c46288b0 BB	186
c46288b0 BB	187	if (hour < 12)
fe20ba70	188	return bin2bcd(hour);
c46288b0	189
fe20ba70	190	return 0x40 \| bin2bcd(hour - 12);
c46288b0 BB	191	}
	192
	193	static int s35390a_reg2hr(struct s35390a *s35390a, char reg)
	194	{
	195	unsigned hour;
	196
	197	if (s35390a->twentyfourhour)
fe20ba70	198	return bcd2bin(reg & 0x3f);
c46288b0	199
fe20ba70	200	hour = bcd2bin(reg & 0x3f);
c46288b0 BB	201	if (reg & 0x40)
	202	hour += 12;
	203
	204	return hour;
	205	}
	206
	207	static int s35390a_set_datetime(struct i2c_client client, struct rtc_time tm)
	208	{
	209	struct s35390a *s35390a = i2c_get_clientdata(client);
	210	int i, err;
	211	char buf[7];
	212
	213	dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d mday=%d, "
	214	"mon=%d, year=%d, wday=%d\n", __func__, tm->tm_sec,
	215	tm->tm_min, tm->tm_hour, tm->tm_mday, tm->tm_mon, tm->tm_year,
	216	tm->tm_wday);
	217
fe20ba70 AB	218	buf[S35390A_BYTE_YEAR] = bin2bcd(tm->tm_year - 100);
	219	buf[S35390A_BYTE_MONTH] = bin2bcd(tm->tm_mon + 1);
	220	buf[S35390A_BYTE_DAY] = bin2bcd(tm->tm_mday);
	221	buf[S35390A_BYTE_WDAY] = bin2bcd(tm->tm_wday);
c46288b0	222	buf[S35390A_BYTE_HOURS] = s35390a_hr2reg(s35390a, tm->tm_hour);
fe20ba70 AB	223	buf[S35390A_BYTE_MINS] = bin2bcd(tm->tm_min);
fe20ba70 AB	224	buf[S35390A_BYTE_SECS] = bin2bcd(tm->tm_sec);
c46288b0 BB	225
	226	/* This chip expects the bits of each byte to be in reverse order */
	227	for (i = 0; i < 7; ++i)
	228	buf[i] = bitrev8(buf[i]);
	229
	230	err = s35390a_set_reg(s35390a, S35390A_CMD_TIME1, buf, sizeof(buf));
	231
	232	return err;
	233	}
	234
	235	static int s35390a_get_datetime(struct i2c_client client, struct rtc_time tm)
	236	{
	237	struct s35390a *s35390a = i2c_get_clientdata(client);
	238	char buf[7];
	239	int i, err;
	240
	241	err = s35390a_get_reg(s35390a, S35390A_CMD_TIME1, buf, sizeof(buf));
	242	if (err < 0)
	243	return err;
	244
	245	/* This chip returns the bits of each byte in reverse order */
	246	for (i = 0; i < 7; ++i)
	247	buf[i] = bitrev8(buf[i]);
	248
fe20ba70 AB	249	tm->tm_sec = bcd2bin(buf[S35390A_BYTE_SECS]);
fe20ba70 AB	250	tm->tm_min = bcd2bin(buf[S35390A_BYTE_MINS]);
c46288b0	251	tm->tm_hour = s35390a_reg2hr(s35390a, buf[S35390A_BYTE_HOURS]);
fe20ba70 AB	252	tm->tm_wday = bcd2bin(buf[S35390A_BYTE_WDAY]);
	253	tm->tm_mday = bcd2bin(buf[S35390A_BYTE_DAY]);
	254	tm->tm_mon = bcd2bin(buf[S35390A_BYTE_MONTH]) - 1;
	255	tm->tm_year = bcd2bin(buf[S35390A_BYTE_YEAR]) + 100;
c46288b0 BB	256
	257	dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d, mday=%d, "
	258	"mon=%d, year=%d, wday=%d\n", __func__, tm->tm_sec,
	259	tm->tm_min, tm->tm_hour, tm->tm_mday, tm->tm_mon, tm->tm_year,
	260	tm->tm_wday);
	261
	262	return rtc_valid_tm(tm);
	263	}
	264
542dd33a ML	265	static int s35390a_set_alarm(struct i2c_client client, struct rtc_wkalrm alm)
	266	{
	267	struct s35390a *s35390a = i2c_get_clientdata(client);
	268	char buf[3], sts = 0;
	269	int err, i;
	270
	271	dev_dbg(&client->dev, "%s: alm is secs=%d, mins=%d, hours=%d mday=%d, "\
	272	"mon=%d, year=%d, wday=%d\n", __func__, alm->time.tm_sec,
	273	alm->time.tm_min, alm->time.tm_hour, alm->time.tm_mday,
	274	alm->time.tm_mon, alm->time.tm_year, alm->time.tm_wday);
	275
5227e8a2	276	/* disable interrupt (which deasserts the irq line) */
542dd33a ML	277	err = s35390a_set_reg(s35390a, S35390A_CMD_STATUS2, &sts, sizeof(sts));
	278	if (err < 0)
	279	return err;
	280
5227e8a2	281	/* clear pending interrupt (in STATUS1 only), if any */
542dd33a ML	282	err = s35390a_get_reg(s35390a, S35390A_CMD_STATUS1, &sts, sizeof(sts));
	283	if (err < 0)
	284	return err;
	285
	286	if (alm->enabled)
	287	sts = S35390A_INT2_MODE_ALARM;
	288	else
	289	sts = S35390A_INT2_MODE_NOINTR;
	290
	291	/* This chip expects the bits of each byte to be in reverse order */
	292	sts = bitrev8(sts);
	293
	294	/* set interupt mode*/
	295	err = s35390a_set_reg(s35390a, S35390A_CMD_STATUS2, &sts, sizeof(sts));
	296	if (err < 0)
	297	return err;
	298
	299	if (alm->time.tm_wday != -1)
	300	buf[S35390A_ALRM_BYTE_WDAY] = bin2bcd(alm->time.tm_wday) \| 0x80;
f87e904d UKK	301	else
f87e904d UKK	302	buf[S35390A_ALRM_BYTE_WDAY] = 0;
542dd33a ML	303
	304	buf[S35390A_ALRM_BYTE_HOURS] = s35390a_hr2reg(s35390a,
	305	alm->time.tm_hour) \| 0x80;
	306	buf[S35390A_ALRM_BYTE_MINS] = bin2bcd(alm->time.tm_min) \| 0x80;
	307
	308	if (alm->time.tm_hour >= 12)
	309	buf[S35390A_ALRM_BYTE_HOURS] \|= 0x40;
	310
	311	for (i = 0; i < 3; ++i)
	312	buf[i] = bitrev8(buf[i]);
	313
	314	err = s35390a_set_reg(s35390a, S35390A_CMD_INT2_REG1, buf,
	315	sizeof(buf));
	316
	317	return err;
	318	}
	319
	320	static int s35390a_read_alarm(struct i2c_client client, struct rtc_wkalrm alm)
	321	{
	322	struct s35390a *s35390a = i2c_get_clientdata(client);
	323	char buf[3], sts;
	324	int i, err;
	325
	326	err = s35390a_get_reg(s35390a, S35390A_CMD_STATUS2, &sts, sizeof(sts));
	327	if (err < 0)
	328	return err;
	329
f87e904d UKK	330	if ((bitrev8(sts) & S35390A_INT2_MODE_MASK) != S35390A_INT2_MODE_ALARM) {
	331	/*
	332	* When the alarm isn't enabled, the register to configure
	333	* the alarm time isn't accessible.
	334	*/
	335	alm->enabled = 0;
	336	return 0;
	337	} else {
	338	alm->enabled = 1;
	339	}
542dd33a ML	340
	341	err = s35390a_get_reg(s35390a, S35390A_CMD_INT2_REG1, buf, sizeof(buf));
	342	if (err < 0)
	343	return err;
	344
	345	/* This chip returns the bits of each byte in reverse order */
f87e904d	346	for (i = 0; i < 3; ++i)
542dd33a	347	buf[i] = bitrev8(buf[i]);
542dd33a	348
f87e904d UKK	349	/*
	350	* B0 of the three matching registers is an enable flag. Iff it is set
	351	* the configured value is used for matching.
	352	*/
	353	if (buf[S35390A_ALRM_BYTE_WDAY] & 0x80)
	354	alm->time.tm_wday =
	355	bcd2bin(buf[S35390A_ALRM_BYTE_WDAY] & ~0x80);
	356
	357	if (buf[S35390A_ALRM_BYTE_HOURS] & 0x80)
	358	alm->time.tm_hour =
	359	s35390a_reg2hr(s35390a,
	360	buf[S35390A_ALRM_BYTE_HOURS] & ~0x80);
	361
	362	if (buf[S35390A_ALRM_BYTE_MINS] & 0x80)
	363	alm->time.tm_min = bcd2bin(buf[S35390A_ALRM_BYTE_MINS] & ~0x80);
	364
	365	/* alarm triggers always at s=0 */
	366	alm->time.tm_sec = 0;
542dd33a ML	367
	368	dev_dbg(&client->dev, "%s: alm is mins=%d, hours=%d, wday=%d\n",
	369	__func__, alm->time.tm_min, alm->time.tm_hour,
	370	alm->time.tm_wday);
	371
	372	return 0;
	373	}
	374
	375	static int s35390a_rtc_read_alarm(struct device dev, struct rtc_wkalrm alm)
	376	{
	377	return s35390a_read_alarm(to_i2c_client(dev), alm);
	378	}
	379
	380	static int s35390a_rtc_set_alarm(struct device dev, struct rtc_wkalrm alm)
	381	{
	382	return s35390a_set_alarm(to_i2c_client(dev), alm);
	383	}
	384
c46288b0 BB	385	static int s35390a_rtc_read_time(struct device dev, struct rtc_time tm)
	386	{
	387	return s35390a_get_datetime(to_i2c_client(dev), tm);
	388	}
	389
	390	static int s35390a_rtc_set_time(struct device dev, struct rtc_time tm)
	391	{
	392	return s35390a_set_datetime(to_i2c_client(dev), tm);
	393	}
	394
	395	static const struct rtc_class_ops s35390a_rtc_ops = {
	396	.read_time = s35390a_rtc_read_time,
	397	.set_time = s35390a_rtc_set_time,
542dd33a ML	398	.set_alarm = s35390a_rtc_set_alarm,
	399	.read_alarm = s35390a_rtc_read_alarm,
	400
c46288b0 BB	401	};
	402
	403	static struct i2c_driver s35390a_driver;
	404
d2653e92 JD	405	static int s35390a_probe(struct i2c_client *client,
d2653e92 JD	406	const struct i2c_device_id *id)
c46288b0	407	{
3bd32722	408	int err, err_reset;
c46288b0 BB	409	unsigned int i;
	410	struct s35390a *s35390a;
	411	struct rtc_time tm;
3bd32722	412	char buf, status1;
c46288b0 BB	413
	414	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
	415	err = -ENODEV;
	416	goto exit;
	417	}
	418
b4cd3d6a JH	419	s35390a = devm_kzalloc(&client->dev, sizeof(struct s35390a),
b4cd3d6a JH	420	GFP_KERNEL);
c46288b0 BB	421	if (!s35390a) {
	422	err = -ENOMEM;
	423	goto exit;
	424	}
	425
	426	s35390a->client[0] = client;
	427	i2c_set_clientdata(client, s35390a);
	428
	429	/* This chip uses multiple addresses, use dummy devices for them */
	430	for (i = 1; i < 8; ++i) {
	431	s35390a->client[i] = i2c_new_dummy(client->adapter,
60b129d7	432	client->addr + i);
c46288b0 BB	433	if (!s35390a->client[i]) {
	434	dev_err(&client->dev, "Address %02x unavailable\n",
	435	client->addr + i);
	436	err = -EBUSY;
	437	goto exit_dummy;
	438	}
	439	}
	440
3bd32722 UKK	441	err_reset = s35390a_reset(s35390a, &status1);
	442	if (err_reset < 0) {
	443	err = err_reset;
c46288b0 BB	444	dev_err(&client->dev, "error resetting chip\n");
	445	goto exit_dummy;
	446	}
	447
3bd32722	448	if (status1 & S35390A_FLAG_24H)
c46288b0 BB	449	s35390a->twentyfourhour = 1;
	450	else
	451	s35390a->twentyfourhour = 0;
	452
3bd32722 UKK	453	if (status1 & S35390A_FLAG_INT2) {
	454	/* disable alarm (and maybe test mode) */
	455	buf = 0;
	456	err = s35390a_set_reg(s35390a, S35390A_CMD_STATUS2, &buf, 1);
	457	if (err < 0) {
	458	dev_err(&client->dev, "error disabling alarm");
	459	goto exit_dummy;
	460	}
	461	} else {
	462	err = s35390a_disable_test_mode(s35390a);
	463	if (err < 0) {
	464	dev_err(&client->dev, "error disabling test mode\n");
	465	goto exit_dummy;
	466	}
	467	}
	468
	469	if (err_reset > 0 \|\| s35390a_get_datetime(client, &tm) < 0)
c46288b0 BB	470	dev_warn(&client->dev, "clock needs to be set\n");
c46288b0 BB	471
542dd33a ML	472	device_set_wakeup_capable(&client->dev, 1);
542dd33a ML	473
b4cd3d6a JH	474	s35390a->rtc = devm_rtc_device_register(&client->dev,
	475	s35390a_driver.driver.name,
	476	&s35390a_rtc_ops, THIS_MODULE);
c46288b0 BB	477
	478	if (IS_ERR(s35390a->rtc)) {
	479	err = PTR_ERR(s35390a->rtc);
	480	goto exit_dummy;
	481	}
3bd32722 UKK	482
	483	if (status1 & S35390A_FLAG_INT2)
	484	rtc_update_irq(s35390a->rtc, 1, RTC_AF);
	485
c46288b0 BB	486	return 0;
	487
	488	exit_dummy:
	489	for (i = 1; i < 8; ++i)
	490	if (s35390a->client[i])
	491	i2c_unregister_device(s35390a->client[i]);
c46288b0 BB	492
	493	exit:
	494	return err;
	495	}
	496
	497	static int s35390a_remove(struct i2c_client *client)
	498	{
	499	unsigned int i;
c46288b0	500	struct s35390a *s35390a = i2c_get_clientdata(client);
b4cd3d6a	501
c46288b0 BB	502	for (i = 1; i < 8; ++i)
	503	if (s35390a->client[i])
	504	i2c_unregister_device(s35390a->client[i]);
	505
c46288b0 BB	506	return 0;
	507	}
	508
	509	static struct i2c_driver s35390a_driver = {
	510	.driver = {
	511	.name = "rtc-s35390a",
21f27432	512	.of_match_table = of_match_ptr(s35390a_of_match),
c46288b0 BB	513	},
	514	.probe = s35390a_probe,
	515	.remove = s35390a_remove,
3760f736	516	.id_table = s35390a_id,
c46288b0 BB	517	};
c46288b0 BB	518
0abc9201	519	module_i2c_driver(s35390a_driver);
c46288b0 BB	520
	521	MODULE_AUTHOR("Byron Bradley <byron.bbradley@gmail.com>");
	522	MODULE_DESCRIPTION("S35390A RTC driver");
	523	MODULE_LICENSE("GPL");