[linux-block.git] / drivers / rtc / rtc-ds1374.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * RTC client/driver for the Maxim/Dallas DS1374 Real-Time Clock over I2C
 *
 * Based on code by Randy Vinson <rvinson@mvista.com>,
 * which was based on the m41t00.c by Mark Greer <mgreer@mvista.com>.
 *
 * Copyright (C) 2014 Rose Technology
 * Copyright (C) 2006-2007 Freescale Semiconductor
 * Copyright (c) 2005 MontaVista Software, Inc.
 */
/*
 * It would be more efficient to use i2c msgs/i2c_transfer directly but, as
 * recommended in .../Documentation/i2c/writing-clients.rst section
 * "Sending and receiving", using SMBus level communication is preferred.
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/interrupt.h>
#include <linux/i2c.h>
#include <linux/rtc.h>
#include <linux/bcd.h>
#include <linux/workqueue.h>
#include <linux/slab.h>
#include <linux/pm.h>
#ifdef CONFIG_RTC_DRV_DS1374_WDT
#include <linux/fs.h>
#include <linux/ioctl.h>
#include <linux/miscdevice.h>
#include <linux/reboot.h>
#include <linux/watchdog.h>
#endif

#define DS1374_REG_TOD0		0x00 /* Time of Day */
#define DS1374_REG_TOD1		0x01
#define DS1374_REG_TOD2		0x02
#define DS1374_REG_TOD3		0x03
#define DS1374_REG_WDALM0	0x04 /* Watchdog/Alarm */
#define DS1374_REG_WDALM1	0x05
#define DS1374_REG_WDALM2	0x06
#define DS1374_REG_CR		0x07 /* Control */
#define DS1374_REG_CR_AIE	0x01 /* Alarm Int. Enable */
#define DS1374_REG_CR_WDSTR	0x08 /* 1=INT, 0=RST */
#define DS1374_REG_CR_WDALM	0x20 /* 1=Watchdog, 0=Alarm */
#define DS1374_REG_CR_WACE	0x40 /* WD/Alarm counter enable */
#define DS1374_REG_SR		0x08 /* Status */
#define DS1374_REG_SR_OSF	0x80 /* Oscillator Stop Flag */
#define DS1374_REG_SR_AF	0x01 /* Alarm Flag */
#define DS1374_REG_TCR		0x09 /* Trickle Charge */

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

#ifdef CONFIG_OF
static const struct of_device_id ds1374_of_match[] = {
	{ .compatible = "dallas,ds1374" },
	{ }
};
MODULE_DEVICE_TABLE(of, ds1374_of_match);
#endif

struct ds1374 {
	struct i2c_client *client;
	struct rtc_device *rtc;
	struct work_struct work;
#ifdef CONFIG_RTC_DRV_DS1374_WDT
	struct watchdog_device wdt;
#endif
	/* The mutex protects alarm operations, and prevents a race
	 * between the enable_irq() in the workqueue and the free_irq()
	 * in the remove function.
	 */
	struct mutex mutex;
	int exiting;
};

static struct i2c_driver ds1374_driver;

static int ds1374_read_rtc(struct i2c_client *client, u32 *time,
			   int reg, int nbytes)
{
	u8 buf[4];
	int ret;
	int i;

	if (WARN_ON(nbytes > 4))
		return -EINVAL;

	ret = i2c_smbus_read_i2c_block_data(client, reg, nbytes, buf);

	if (ret < 0)
		return ret;
	if (ret < nbytes)
		return -EIO;

	for (i = nbytes - 1, *time = 0; i >= 0; i--)
		*time = (*time << 8) | buf[i];

	return 0;
}

static int ds1374_write_rtc(struct i2c_client *client, u32 time,
			    int reg, int nbytes)
{
	u8 buf[4];
	int i;

	if (nbytes > 4) {
		WARN_ON(1);
		return -EINVAL;
	}

	for (i = 0; i < nbytes; i++) {
		buf[i] = time & 0xff;
		time >>= 8;
	}

	return i2c_smbus_write_i2c_block_data(client, reg, nbytes, buf);
}

static int ds1374_check_rtc_status(struct i2c_client *client)
{
	int ret = 0;
	int control, stat;

	stat = i2c_smbus_read_byte_data(client, DS1374_REG_SR);
	if (stat < 0)
		return stat;

	if (stat & DS1374_REG_SR_OSF)
		dev_warn(&client->dev,
			 "oscillator discontinuity flagged, time unreliable\n");

	stat &= ~(DS1374_REG_SR_OSF | DS1374_REG_SR_AF);

	ret = i2c_smbus_write_byte_data(client, DS1374_REG_SR, stat);
	if (ret < 0)
		return ret;

	/* If the alarm is pending, clear it before requesting
	 * the interrupt, so an interrupt event isn't reported
	 * before everything is initialized.
	 */

	control = i2c_smbus_read_byte_data(client, DS1374_REG_CR);
	if (control < 0)
		return control;

	control &= ~(DS1374_REG_CR_WACE | DS1374_REG_CR_AIE);
	return i2c_smbus_write_byte_data(client, DS1374_REG_CR, control);
}

static int ds1374_read_time(struct device *dev, struct rtc_time *time)
{
	struct i2c_client *client = to_i2c_client(dev);
	u32 itime;
	int ret;

	ret = ds1374_read_rtc(client, &itime, DS1374_REG_TOD0, 4);
	if (!ret)
		rtc_time64_to_tm(itime, time);

	return ret;
}

static int ds1374_set_time(struct device *dev, struct rtc_time *time)
{
	struct i2c_client *client = to_i2c_client(dev);
	unsigned long itime = rtc_tm_to_time64(time);

	return ds1374_write_rtc(client, itime, DS1374_REG_TOD0, 4);
}

#ifndef CONFIG_RTC_DRV_DS1374_WDT
/* The ds1374 has a decrementer for an alarm, rather than a comparator.
 * If the time of day is changed, then the alarm will need to be
 * reset.
 */
static int ds1374_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct ds1374 *ds1374 = i2c_get_clientdata(client);
	u32 now, cur_alarm;
	int cr, sr;
	int ret = 0;

	if (client->irq <= 0)
		return -EINVAL;

	mutex_lock(&ds1374->mutex);

	cr = ret = i2c_smbus_read_byte_data(client, DS1374_REG_CR);
	if (ret < 0)
		goto out;

	sr = ret = i2c_smbus_read_byte_data(client, DS1374_REG_SR);
	if (ret < 0)
		goto out;

	ret = ds1374_read_rtc(client, &now, DS1374_REG_TOD0, 4);
	if (ret)
		goto out;

	ret = ds1374_read_rtc(client, &cur_alarm, DS1374_REG_WDALM0, 3);
	if (ret)
		goto out;

	rtc_time64_to_tm(now + cur_alarm, &alarm->time);
	alarm->enabled = !!(cr & DS1374_REG_CR_WACE);
	alarm->pending = !!(sr & DS1374_REG_SR_AF);

out:
	mutex_unlock(&ds1374->mutex);
	return ret;
}

static int ds1374_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct ds1374 *ds1374 = i2c_get_clientdata(client);
	struct rtc_time now;
	unsigned long new_alarm, itime;
	int cr;
	int ret = 0;

	if (client->irq <= 0)
		return -EINVAL;

	ret = ds1374_read_time(dev, &now);
	if (ret < 0)
		return ret;

	new_alarm = rtc_tm_to_time64(&alarm->time);
	itime = rtc_tm_to_time64(&now);

	/* This can happen due to races, in addition to dates that are
	 * truly in the past.  To avoid requiring the caller to check for
	 * races, dates in the past are assumed to be in the recent past
	 * (i.e. not something that we'd rather the caller know about via
	 * an error), and the alarm is set to go off as soon as possible.
	 */
	if (time_before_eq(new_alarm, itime))
		new_alarm = 1;
	else
		new_alarm -= itime;

	mutex_lock(&ds1374->mutex);

	ret = cr = i2c_smbus_read_byte_data(client, DS1374_REG_CR);
	if (ret < 0)
		goto out;

	/* Disable any existing alarm before setting the new one
	 * (or lack thereof). */
	cr &= ~DS1374_REG_CR_WACE;

	ret = i2c_smbus_write_byte_data(client, DS1374_REG_CR, cr);
	if (ret < 0)
		goto out;

	ret = ds1374_write_rtc(client, new_alarm, DS1374_REG_WDALM0, 3);
	if (ret)
		goto out;

	if (alarm->enabled) {
		cr |= DS1374_REG_CR_WACE | DS1374_REG_CR_AIE;
		cr &= ~DS1374_REG_CR_WDALM;

		ret = i2c_smbus_write_byte_data(client, DS1374_REG_CR, cr);
	}

out:
	mutex_unlock(&ds1374->mutex);
	return ret;
}
#endif

static irqreturn_t ds1374_irq(int irq, void *dev_id)
{
	struct i2c_client *client = dev_id;
	struct ds1374 *ds1374 = i2c_get_clientdata(client);

	disable_irq_nosync(irq);
	schedule_work(&ds1374->work);
	return IRQ_HANDLED;
}

static void ds1374_work(struct work_struct *work)
{
	struct ds1374 *ds1374 = container_of(work, struct ds1374, work);
	struct i2c_client *client = ds1374->client;
	int stat, control;

	mutex_lock(&ds1374->mutex);

	stat = i2c_smbus_read_byte_data(client, DS1374_REG_SR);
	if (stat < 0)
		goto unlock;

	if (stat & DS1374_REG_SR_AF) {
		stat &= ~DS1374_REG_SR_AF;
		i2c_smbus_write_byte_data(client, DS1374_REG_SR, stat);

		control = i2c_smbus_read_byte_data(client, DS1374_REG_CR);
		if (control < 0)
			goto out;

		control &= ~(DS1374_REG_CR_WACE | DS1374_REG_CR_AIE);
		i2c_smbus_write_byte_data(client, DS1374_REG_CR, control);

		rtc_update_irq(ds1374->rtc, 1, RTC_AF | RTC_IRQF);
	}

out:
	if (!ds1374->exiting)
		enable_irq(client->irq);
unlock:
	mutex_unlock(&ds1374->mutex);
}

#ifndef CONFIG_RTC_DRV_DS1374_WDT
static int ds1374_alarm_irq_enable(struct device *dev, unsigned int enabled)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct ds1374 *ds1374 = i2c_get_clientdata(client);
	int ret;

	mutex_lock(&ds1374->mutex);

	ret = i2c_smbus_read_byte_data(client, DS1374_REG_CR);
	if (ret < 0)
		goto out;

	if (enabled) {
		ret |= DS1374_REG_CR_WACE | DS1374_REG_CR_AIE;
		ret &= ~DS1374_REG_CR_WDALM;
	} else {
		ret &= ~DS1374_REG_CR_WACE;
	}
	ret = i2c_smbus_write_byte_data(client, DS1374_REG_CR, ret);

out:
	mutex_unlock(&ds1374->mutex);
	return ret;
}
#endif

static const struct rtc_class_ops ds1374_rtc_ops = {
	.read_time = ds1374_read_time,
	.set_time = ds1374_set_time,
#ifndef CONFIG_RTC_DRV_DS1374_WDT
	.read_alarm = ds1374_read_alarm,
	.set_alarm = ds1374_set_alarm,
	.alarm_irq_enable = ds1374_alarm_irq_enable,
#endif
};

#ifdef CONFIG_RTC_DRV_DS1374_WDT
/*
 *****************************************************************************
 *
 * Watchdog Driver
 *
 *****************************************************************************
 */
/* Default margin */
#define TIMER_MARGIN_DEFAULT	32
#define TIMER_MARGIN_MIN	1
#define TIMER_MARGIN_MAX	4095 /* 24-bit value */

static int wdt_margin;
module_param(wdt_margin, int, 0);
MODULE_PARM_DESC(wdt_margin, "Watchdog timeout in seconds (default 32s)");

static bool nowayout = WATCHDOG_NOWAYOUT;
module_param(nowayout, bool, 0);
MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default ="
		__MODULE_STRING(WATCHDOG_NOWAYOUT)")");

static const struct watchdog_info ds1374_wdt_info = {
	.identity       = "DS1374 Watchdog",
	.options        = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING |
						WDIOF_MAGICCLOSE,
};

static int ds1374_wdt_settimeout(struct watchdog_device *wdt, unsigned int timeout)
{
	struct ds1374 *ds1374 = watchdog_get_drvdata(wdt);
	struct i2c_client *client = ds1374->client;
	int ret, cr;

	wdt->timeout = timeout;

	cr = i2c_smbus_read_byte_data(client, DS1374_REG_CR);
	if (cr < 0)
		return cr;

	/* Disable any existing watchdog/alarm before setting the new one */
	cr &= ~DS1374_REG_CR_WACE;

	ret = i2c_smbus_write_byte_data(client, DS1374_REG_CR, cr);
	if (ret < 0)
		return ret;

	/* Set new watchdog time */
	timeout = timeout * 4096;
	ret = ds1374_write_rtc(client, timeout, DS1374_REG_WDALM0, 3);
	if (ret)
		return ret;

	/* Enable watchdog timer */
	cr |= DS1374_REG_CR_WACE | DS1374_REG_CR_WDALM;
	cr &= ~DS1374_REG_CR_WDSTR;/* for RST PIN */
	cr &= ~DS1374_REG_CR_AIE;

	ret = i2c_smbus_write_byte_data(client, DS1374_REG_CR, cr);
	if (ret < 0)
		return ret;

	return 0;
}

/*
 * Reload the watchdog timer.  (ie, pat the watchdog)
 */
static int ds1374_wdt_start(struct watchdog_device *wdt)
{
	struct ds1374 *ds1374 = watchdog_get_drvdata(wdt);
	u32 val;

	return ds1374_read_rtc(ds1374->client, &val, DS1374_REG_WDALM0, 3);
}

static int ds1374_wdt_stop(struct watchdog_device *wdt)
{
	struct ds1374 *ds1374 = watchdog_get_drvdata(wdt);
	struct i2c_client *client = ds1374->client;
	int cr;

	cr = i2c_smbus_read_byte_data(client, DS1374_REG_CR);
	if (cr < 0)
		return cr;

	/* Disable watchdog timer */
	cr &= ~DS1374_REG_CR_WACE;

	return i2c_smbus_write_byte_data(client, DS1374_REG_CR, cr);
}

static const struct watchdog_ops ds1374_wdt_ops = {
	.owner          = THIS_MODULE,
	.start          = ds1374_wdt_start,
	.stop           = ds1374_wdt_stop,
	.set_timeout    = ds1374_wdt_settimeout,
};
#endif /*CONFIG_RTC_DRV_DS1374_WDT*/
/*
 *****************************************************************************
 *
 *	Driver Interface
 *
 *****************************************************************************
 */
static int ds1374_probe(struct i2c_client *client)
{
	struct ds1374 *ds1374;
	int ret;

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

	ds1374->rtc = devm_rtc_allocate_device(&client->dev);
	if (IS_ERR(ds1374->rtc))
		return PTR_ERR(ds1374->rtc);

	ds1374->client = client;
	i2c_set_clientdata(client, ds1374);

	INIT_WORK(&ds1374->work, ds1374_work);
	mutex_init(&ds1374->mutex);

	ret = ds1374_check_rtc_status(client);
	if (ret)
		return ret;

	if (client->irq > 0) {
		ret = devm_request_irq(&client->dev, client->irq, ds1374_irq, 0,
					"ds1374", client);
		if (ret) {
			dev_err(&client->dev, "unable to request IRQ\n");
			return ret;
		}

		device_set_wakeup_capable(&client->dev, 1);
	}

	ds1374->rtc->ops = &ds1374_rtc_ops;
	ds1374->rtc->range_max = U32_MAX;

	ret = devm_rtc_register_device(ds1374->rtc);
	if (ret)
		return ret;

#ifdef CONFIG_RTC_DRV_DS1374_WDT
	ds1374->wdt.info = &ds1374_wdt_info;
	ds1374->wdt.ops = &ds1374_wdt_ops;
	ds1374->wdt.timeout = TIMER_MARGIN_DEFAULT;
	ds1374->wdt.min_timeout = TIMER_MARGIN_MIN;
	ds1374->wdt.max_timeout = TIMER_MARGIN_MAX;

	watchdog_init_timeout(&ds1374->wdt, wdt_margin, &client->dev);
	watchdog_set_nowayout(&ds1374->wdt, nowayout);
	watchdog_stop_on_reboot(&ds1374->wdt);
	watchdog_stop_on_unregister(&ds1374->wdt);
	watchdog_set_drvdata(&ds1374->wdt, ds1374);
	ds1374_wdt_settimeout(&ds1374->wdt, ds1374->wdt.timeout);

	ret = devm_watchdog_register_device(&client->dev, &ds1374->wdt);
	if (ret)
		return ret;
#endif

	return 0;
}

static void ds1374_remove(struct i2c_client *client)
{
	struct ds1374 *ds1374 = i2c_get_clientdata(client);

	if (client->irq > 0) {
		mutex_lock(&ds1374->mutex);
		ds1374->exiting = 1;
		mutex_unlock(&ds1374->mutex);

		devm_free_irq(&client->dev, client->irq, client);
		cancel_work_sync(&ds1374->work);
	}
}

#ifdef CONFIG_PM_SLEEP
static int ds1374_suspend(struct device *dev)
{
	struct i2c_client *client = to_i2c_client(dev);

	if (client->irq > 0 && device_may_wakeup(&client->dev))
		enable_irq_wake(client->irq);
	return 0;
}

static int ds1374_resume(struct device *dev)
{
	struct i2c_client *client = to_i2c_client(dev);

	if (client->irq > 0 && device_may_wakeup(&client->dev))
		disable_irq_wake(client->irq);
	return 0;
}
#endif

static SIMPLE_DEV_PM_OPS(ds1374_pm, ds1374_suspend, ds1374_resume);

static struct i2c_driver ds1374_driver = {
	.driver = {
		.name = "rtc-ds1374",
		.of_match_table = of_match_ptr(ds1374_of_match),
		.pm = &ds1374_pm,
	},
	.probe_new = ds1374_probe,
	.remove = ds1374_remove,
	.id_table = ds1374_id,
};

module_i2c_driver(ds1374_driver);

MODULE_AUTHOR("Scott Wood <scottwood@freescale.com>");
MODULE_DESCRIPTION("Maxim/Dallas DS1374 RTC Driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
67561a8e	1	// SPDX-License-Identifier: GPL-2.0-only
bf4994d7 SW	2	/*
	3	* RTC client/driver for the Maxim/Dallas DS1374 Real-Time Clock over I2C
	4	*
	5	* Based on code by Randy Vinson <rvinson@mvista.com>,
	6	* which was based on the m41t00.c by Mark Greer <mgreer@mvista.com>.
	7	*
920f91e5	8	* Copyright (C) 2014 Rose Technology
bf4994d7	9	* Copyright (C) 2006-2007 Freescale Semiconductor
67561a8e	10	* Copyright (c) 2005 MontaVista Software, Inc.
bf4994d7 SW	11	*/
	12	/*
	13	* It would be more efficient to use i2c msgs/i2c_transfer directly but, as
ccf988b6	14	* recommended in .../Documentation/i2c/writing-clients.rst section
bf4994d7 SW	15	* "Sending and receiving", using SMBus level communication is preferred.
	16	*/
	17
a737e835 JP	18	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
a737e835 JP	19
bf4994d7 SW	20	#include <linux/kernel.h>
	21	#include <linux/module.h>
	22	#include <linux/interrupt.h>
	23	#include <linux/i2c.h>
	24	#include <linux/rtc.h>
	25	#include <linux/bcd.h>
	26	#include <linux/workqueue.h>
5a0e3ad6	27	#include <linux/slab.h>
bc96ba74	28	#include <linux/pm.h>
920f91e5 SA	29	#ifdef CONFIG_RTC_DRV_DS1374_WDT
	30	#include <linux/fs.h>
	31	#include <linux/ioctl.h>
	32	#include <linux/miscdevice.h>
	33	#include <linux/reboot.h>
	34	#include <linux/watchdog.h>
	35	#endif
bf4994d7 SW	36
	37	#define DS1374_REG_TOD0 0x00 /* Time of Day */
	38	#define DS1374_REG_TOD1 0x01
	39	#define DS1374_REG_TOD2 0x02
	40	#define DS1374_REG_TOD3 0x03
	41	#define DS1374_REG_WDALM0 0x04 /* Watchdog/Alarm */
	42	#define DS1374_REG_WDALM1 0x05
	43	#define DS1374_REG_WDALM2 0x06
	44	#define DS1374_REG_CR 0x07 /* Control */
	45	#define DS1374_REG_CR_AIE 0x01 /* Alarm Int. Enable */
d3de4beb	46	#define DS1374_REG_CR_WDSTR 0x08 /* 1=INT, 0=RST */
bf4994d7 SW	47	#define DS1374_REG_CR_WDALM 0x20 /* 1=Watchdog, 0=Alarm */
	48	#define DS1374_REG_CR_WACE 0x40 /* WD/Alarm counter enable */
	49	#define DS1374_REG_SR 0x08 /* Status */
	50	#define DS1374_REG_SR_OSF 0x80 /* Oscillator Stop Flag */
	51	#define DS1374_REG_SR_AF 0x01 /* Alarm Flag */
	52	#define DS1374_REG_TCR 0x09 /* Trickle Charge */
	53
3760f736	54	static const struct i2c_device_id ds1374_id[] = {
f2eb4327	55	{ "ds1374", 0 },
3760f736 JD	56	{ }
	57	};
	58	MODULE_DEVICE_TABLE(i2c, ds1374_id);
	59
920f91e5 SA	60	#ifdef CONFIG_OF
	61	static const struct of_device_id ds1374_of_match[] = {
	62	{ .compatible = "dallas,ds1374" },
	63	{ }
	64	};
	65	MODULE_DEVICE_TABLE(of, ds1374_of_match);
	66	#endif
	67
bf4994d7 SW	68	struct ds1374 {
	69	struct i2c_client *client;
	70	struct rtc_device *rtc;
	71	struct work_struct work;
d3de4beb JCC	72	#ifdef CONFIG_RTC_DRV_DS1374_WDT
	73	struct watchdog_device wdt;
	74	#endif
bf4994d7 SW	75	/* The mutex protects alarm operations, and prevents a race
	76	* between the enable_irq() in the workqueue and the free_irq()
	77	* in the remove function.
	78	*/
	79	struct mutex mutex;
	80	int exiting;
	81	};
	82
	83	static struct i2c_driver ds1374_driver;
	84
	85	static int ds1374_read_rtc(struct i2c_client client, u32 time,
adc7b9b6	86	int reg, int nbytes)
bf4994d7 SW	87	{
	88	u8 buf[4];
	89	int ret;
	90	int i;
	91
01835fad	92	if (WARN_ON(nbytes > 4))
bf4994d7	93	return -EINVAL;
bf4994d7 SW	94
	95	ret = i2c_smbus_read_i2c_block_data(client, reg, nbytes, buf);
	96
	97	if (ret < 0)
	98	return ret;
	99	if (ret < nbytes)
	100	return -EIO;
	101
	102	for (i = nbytes - 1, *time = 0; i >= 0; i--)
	103	time = (time << 8) \| buf[i];
	104
	105	return 0;
	106	}
	107
	108	static int ds1374_write_rtc(struct i2c_client *client, u32 time,
adc7b9b6	109	int reg, int nbytes)
bf4994d7 SW	110	{
	111	u8 buf[4];
	112	int i;
	113
	114	if (nbytes > 4) {
	115	WARN_ON(1);
	116	return -EINVAL;
	117	}
	118
	119	for (i = 0; i < nbytes; i++) {
	120	buf[i] = time & 0xff;
	121	time >>= 8;
	122	}
	123
	124	return i2c_smbus_write_i2c_block_data(client, reg, nbytes, buf);
	125	}
	126
	127	static int ds1374_check_rtc_status(struct i2c_client *client)
	128	{
	129	int ret = 0;
	130	int control, stat;
	131
	132	stat = i2c_smbus_read_byte_data(client, DS1374_REG_SR);
	133	if (stat < 0)
	134	return stat;
	135
	136	if (stat & DS1374_REG_SR_OSF)
	137	dev_warn(&client->dev,
adc7b9b6	138	"oscillator discontinuity flagged, time unreliable\n");
bf4994d7 SW	139
	140	stat &= ~(DS1374_REG_SR_OSF \| DS1374_REG_SR_AF);
	141
	142	ret = i2c_smbus_write_byte_data(client, DS1374_REG_SR, stat);
	143	if (ret < 0)
	144	return ret;
	145
	146	/* If the alarm is pending, clear it before requesting
	147	* the interrupt, so an interrupt event isn't reported
	148	* before everything is initialized.
	149	*/
	150
	151	control = i2c_smbus_read_byte_data(client, DS1374_REG_CR);
	152	if (control < 0)
	153	return control;
	154
	155	control &= ~(DS1374_REG_CR_WACE \| DS1374_REG_CR_AIE);
	156	return i2c_smbus_write_byte_data(client, DS1374_REG_CR, control);
	157	}
	158
	159	static int ds1374_read_time(struct device dev, struct rtc_time time)
	160	{
	161	struct i2c_client *client = to_i2c_client(dev);
	162	u32 itime;
	163	int ret;
	164
	165	ret = ds1374_read_rtc(client, &itime, DS1374_REG_TOD0, 4);
	166	if (!ret)
ca824be9	167	rtc_time64_to_tm(itime, time);
bf4994d7 SW	168
	169	return ret;
	170	}
	171
	172	static int ds1374_set_time(struct device dev, struct rtc_time time)
	173	{
	174	struct i2c_client *client = to_i2c_client(dev);
ca824be9	175	unsigned long itime = rtc_tm_to_time64(time);
bf4994d7	176
bf4994d7 SW	177	return ds1374_write_rtc(client, itime, DS1374_REG_TOD0, 4);
	178	}
	179
920f91e5	180	#ifndef CONFIG_RTC_DRV_DS1374_WDT
bf4994d7 SW	181	/* The ds1374 has a decrementer for an alarm, rather than a comparator.
	182	* If the time of day is changed, then the alarm will need to be
	183	* reset.
	184	*/
	185	static int ds1374_read_alarm(struct device dev, struct rtc_wkalrm alarm)
	186	{
	187	struct i2c_client *client = to_i2c_client(dev);
	188	struct ds1374 *ds1374 = i2c_get_clientdata(client);
	189	u32 now, cur_alarm;
	190	int cr, sr;
	191	int ret = 0;
	192
b42f9317	193	if (client->irq <= 0)
bf4994d7 SW	194	return -EINVAL;
	195
	196	mutex_lock(&ds1374->mutex);
	197
	198	cr = ret = i2c_smbus_read_byte_data(client, DS1374_REG_CR);
	199	if (ret < 0)
	200	goto out;
	201
	202	sr = ret = i2c_smbus_read_byte_data(client, DS1374_REG_SR);
	203	if (ret < 0)
	204	goto out;
	205
	206	ret = ds1374_read_rtc(client, &now, DS1374_REG_TOD0, 4);
	207	if (ret)
	208	goto out;
	209
	210	ret = ds1374_read_rtc(client, &cur_alarm, DS1374_REG_WDALM0, 3);
	211	if (ret)
	212	goto out;
	213
ca824be9	214	rtc_time64_to_tm(now + cur_alarm, &alarm->time);
bf4994d7 SW	215	alarm->enabled = !!(cr & DS1374_REG_CR_WACE);
	216	alarm->pending = !!(sr & DS1374_REG_SR_AF);
	217
	218	out:
	219	mutex_unlock(&ds1374->mutex);
	220	return ret;
	221	}
	222
	223	static int ds1374_set_alarm(struct device dev, struct rtc_wkalrm alarm)
	224	{
	225	struct i2c_client *client = to_i2c_client(dev);
	226	struct ds1374 *ds1374 = i2c_get_clientdata(client);
	227	struct rtc_time now;
	228	unsigned long new_alarm, itime;
	229	int cr;
	230	int ret = 0;
	231
b42f9317	232	if (client->irq <= 0)
bf4994d7 SW	233	return -EINVAL;
	234
	235	ret = ds1374_read_time(dev, &now);
	236	if (ret < 0)
	237	return ret;
	238
ca824be9 AB	239	new_alarm = rtc_tm_to_time64(&alarm->time);
ca824be9 AB	240	itime = rtc_tm_to_time64(&now);
bf4994d7	241
bf4994d7 SW	242	/* This can happen due to races, in addition to dates that are
	243	* truly in the past. To avoid requiring the caller to check for
	244	* races, dates in the past are assumed to be in the recent past
	245	* (i.e. not something that we'd rather the caller know about via
	246	* an error), and the alarm is set to go off as soon as possible.
	247	*/
fa7af8b1	248	if (time_before_eq(new_alarm, itime))
bf4994d7	249	new_alarm = 1;
fa7af8b1 RK	250	else
fa7af8b1 RK	251	new_alarm -= itime;
bf4994d7 SW	252
	253	mutex_lock(&ds1374->mutex);
	254
	255	ret = cr = i2c_smbus_read_byte_data(client, DS1374_REG_CR);
	256	if (ret < 0)
	257	goto out;
	258
	259	/* Disable any existing alarm before setting the new one
	260	* (or lack thereof). */
	261	cr &= ~DS1374_REG_CR_WACE;
	262
	263	ret = i2c_smbus_write_byte_data(client, DS1374_REG_CR, cr);
	264	if (ret < 0)
	265	goto out;
	266
	267	ret = ds1374_write_rtc(client, new_alarm, DS1374_REG_WDALM0, 3);
	268	if (ret)
	269	goto out;
	270
	271	if (alarm->enabled) {
	272	cr \|= DS1374_REG_CR_WACE \| DS1374_REG_CR_AIE;
	273	cr &= ~DS1374_REG_CR_WDALM;
	274
	275	ret = i2c_smbus_write_byte_data(client, DS1374_REG_CR, cr);
	276	}
	277
	278	out:
	279	mutex_unlock(&ds1374->mutex);
	280	return ret;
	281	}
920f91e5	282	#endif
bf4994d7 SW	283
	284	static irqreturn_t ds1374_irq(int irq, void *dev_id)
	285	{
	286	struct i2c_client *client = dev_id;
	287	struct ds1374 *ds1374 = i2c_get_clientdata(client);
	288
	289	disable_irq_nosync(irq);
	290	schedule_work(&ds1374->work);
	291	return IRQ_HANDLED;
	292	}
	293
	294	static void ds1374_work(struct work_struct *work)
	295	{
	296	struct ds1374 *ds1374 = container_of(work, struct ds1374, work);
	297	struct i2c_client *client = ds1374->client;
	298	int stat, control;
	299
	300	mutex_lock(&ds1374->mutex);
	301
	302	stat = i2c_smbus_read_byte_data(client, DS1374_REG_SR);
	303	if (stat < 0)
28df30e6	304	goto unlock;
bf4994d7 SW	305
	306	if (stat & DS1374_REG_SR_AF) {
	307	stat &= ~DS1374_REG_SR_AF;
	308	i2c_smbus_write_byte_data(client, DS1374_REG_SR, stat);
	309
	310	control = i2c_smbus_read_byte_data(client, DS1374_REG_CR);
	311	if (control < 0)
	312	goto out;
	313
	314	control &= ~(DS1374_REG_CR_WACE \| DS1374_REG_CR_AIE);
	315	i2c_smbus_write_byte_data(client, DS1374_REG_CR, control);
	316
bf4994d7	317	rtc_update_irq(ds1374->rtc, 1, RTC_AF \| RTC_IRQF);
bf4994d7 SW	318	}
	319
	320	out:
	321	if (!ds1374->exiting)
	322	enable_irq(client->irq);
28df30e6	323	unlock:
bf4994d7 SW	324	mutex_unlock(&ds1374->mutex);
	325	}
	326
920f91e5	327	#ifndef CONFIG_RTC_DRV_DS1374_WDT
16380c15	328	static int ds1374_alarm_irq_enable(struct device *dev, unsigned int enabled)
bf4994d7 SW	329	{
	330	struct i2c_client *client = to_i2c_client(dev);
	331	struct ds1374 *ds1374 = i2c_get_clientdata(client);
16380c15	332	int ret;
bf4994d7 SW	333
	334	mutex_lock(&ds1374->mutex);
	335
16380c15 JS	336	ret = i2c_smbus_read_byte_data(client, DS1374_REG_CR);
	337	if (ret < 0)
	338	goto out;
bf4994d7	339
16380c15	340	if (enabled) {
bf4994d7 SW	341	ret \|= DS1374_REG_CR_WACE \| DS1374_REG_CR_AIE;
bf4994d7 SW	342	ret &= ~DS1374_REG_CR_WDALM;
16380c15 JS	343	} else {
16380c15 JS	344	ret &= ~DS1374_REG_CR_WACE;
bf4994d7	345	}
16380c15	346	ret = i2c_smbus_write_byte_data(client, DS1374_REG_CR, ret);
bf4994d7 SW	347
	348	out:
	349	mutex_unlock(&ds1374->mutex);
	350	return ret;
	351	}
920f91e5	352	#endif
bf4994d7 SW	353
	354	static const struct rtc_class_ops ds1374_rtc_ops = {
	355	.read_time = ds1374_read_time,
	356	.set_time = ds1374_set_time,
920f91e5	357	#ifndef CONFIG_RTC_DRV_DS1374_WDT
bf4994d7 SW	358	.read_alarm = ds1374_read_alarm,
bf4994d7 SW	359	.set_alarm = ds1374_set_alarm,
16380c15	360	.alarm_irq_enable = ds1374_alarm_irq_enable,
920f91e5 SA	361	#endif
	362	};
	363
	364	#ifdef CONFIG_RTC_DRV_DS1374_WDT
	365	/*
	366	*****************************************************************************
	367	*
	368	* Watchdog Driver
	369	*
	370	*****************************************************************************
	371	*/
920f91e5	372	/* Default margin */
d3de4beb JCC	373	#define TIMER_MARGIN_DEFAULT 32
	374	#define TIMER_MARGIN_MIN 1
	375	#define TIMER_MARGIN_MAX 4095 /* 24-bit value */
920f91e5	376
d3de4beb	377	static int wdt_margin;
920f91e5 SA	378	module_param(wdt_margin, int, 0);
	379	MODULE_PARM_DESC(wdt_margin, "Watchdog timeout in seconds (default 32s)");
	380
d3de4beb JCC	381	static bool nowayout = WATCHDOG_NOWAYOUT;
	382	module_param(nowayout, bool, 0);
	383	MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default ="
	384	__MODULE_STRING(WATCHDOG_NOWAYOUT)")");
	385
920f91e5	386	static const struct watchdog_info ds1374_wdt_info = {
3d6cfb36	387	.identity = "DS1374 Watchdog",
920f91e5 SA	388	.options = WDIOF_SETTIMEOUT \| WDIOF_KEEPALIVEPING \|
	389	WDIOF_MAGICCLOSE,
	390	};
	391
d3de4beb	392	static int ds1374_wdt_settimeout(struct watchdog_device *wdt, unsigned int timeout)
920f91e5	393	{
d3de4beb JCC	394	struct ds1374 *ds1374 = watchdog_get_drvdata(wdt);
	395	struct i2c_client *client = ds1374->client;
	396	int ret, cr;
920f91e5	397
d3de4beb JCC	398	wdt->timeout = timeout;
	399
	400	cr = i2c_smbus_read_byte_data(client, DS1374_REG_CR);
	401	if (cr < 0)
	402	return cr;
920f91e5 SA	403
	404	/* Disable any existing watchdog/alarm before setting the new one */
	405	cr &= ~DS1374_REG_CR_WACE;
	406
d3de4beb	407	ret = i2c_smbus_write_byte_data(client, DS1374_REG_CR, cr);
920f91e5	408	if (ret < 0)
d3de4beb	409	return ret;
920f91e5 SA	410
920f91e5 SA	411	/* Set new watchdog time */
d3de4beb JCC	412	timeout = timeout * 4096;
	413	ret = ds1374_write_rtc(client, timeout, DS1374_REG_WDALM0, 3);
	414	if (ret)
	415	return ret;
920f91e5 SA	416
	417	/* Enable watchdog timer */
	418	cr \|= DS1374_REG_CR_WACE \| DS1374_REG_CR_WDALM;
d3de4beb	419	cr &= ~DS1374_REG_CR_WDSTR;/* for RST PIN */
920f91e5 SA	420	cr &= ~DS1374_REG_CR_AIE;
920f91e5 SA	421
d3de4beb	422	ret = i2c_smbus_write_byte_data(client, DS1374_REG_CR, cr);
920f91e5	423	if (ret < 0)
d3de4beb	424	return ret;
920f91e5 SA	425
920f91e5 SA	426	return 0;
920f91e5 SA	427	}
920f91e5 SA	428
920f91e5 SA	429	/*
	430	* Reload the watchdog timer. (ie, pat the watchdog)
	431	*/
d3de4beb	432	static int ds1374_wdt_start(struct watchdog_device *wdt)
920f91e5	433	{
d3de4beb	434	struct ds1374 *ds1374 = watchdog_get_drvdata(wdt);
920f91e5	435	u32 val;
920f91e5	436
d3de4beb	437	return ds1374_read_rtc(ds1374->client, &val, DS1374_REG_WDALM0, 3);
920f91e5 SA	438	}
920f91e5 SA	439
d3de4beb	440	static int ds1374_wdt_stop(struct watchdog_device *wdt)
920f91e5	441	{
d3de4beb JCC	442	struct ds1374 *ds1374 = watchdog_get_drvdata(wdt);
d3de4beb JCC	443	struct i2c_client *client = ds1374->client;
920f91e5 SA	444	int cr;
920f91e5 SA	445
d3de4beb JCC	446	cr = i2c_smbus_read_byte_data(client, DS1374_REG_CR);
	447	if (cr < 0)
	448	return cr;
	449
920f91e5 SA	450	/* Disable watchdog timer */
	451	cr &= ~DS1374_REG_CR_WACE;
	452
d3de4beb	453	return i2c_smbus_write_byte_data(client, DS1374_REG_CR, cr);
920f91e5 SA	454	}
920f91e5 SA	455
d3de4beb JCC	456	static const struct watchdog_ops ds1374_wdt_ops = {
	457	.owner = THIS_MODULE,
	458	.start = ds1374_wdt_start,
	459	.stop = ds1374_wdt_stop,
	460	.set_timeout = ds1374_wdt_settimeout,
920f91e5	461	};
920f91e5 SA	462	#endif /CONFIG_RTC_DRV_DS1374_WDT/
	463	/*
	464	*****************************************************************************
	465	*
	466	* Driver Interface
	467	*
	468	*****************************************************************************
	469	*/
3f4a3322	470	static int ds1374_probe(struct i2c_client *client)
bf4994d7 SW	471	{
	472	struct ds1374 *ds1374;
	473	int ret;
	474
d1a96639	475	ds1374 = devm_kzalloc(&client->dev, sizeof(struct ds1374), GFP_KERNEL);
bf4994d7 SW	476	if (!ds1374)
	477	return -ENOMEM;
	478
c11af813 AB	479	ds1374->rtc = devm_rtc_allocate_device(&client->dev);
	480	if (IS_ERR(ds1374->rtc))
	481	return PTR_ERR(ds1374->rtc);
	482
bf4994d7 SW	483	ds1374->client = client;
	484	i2c_set_clientdata(client, ds1374);
	485
	486	INIT_WORK(&ds1374->work, ds1374_work);
	487	mutex_init(&ds1374->mutex);
	488
	489	ret = ds1374_check_rtc_status(client);
	490	if (ret)
d1a96639	491	return ret;
bf4994d7	492
b42f9317	493	if (client->irq > 0) {
d1a96639	494	ret = devm_request_irq(&client->dev, client->irq, ds1374_irq, 0,
adc7b9b6	495	"ds1374", client);
bf4994d7 SW	496	if (ret) {
bf4994d7 SW	497	dev_err(&client->dev, "unable to request IRQ\n");
d1a96639	498	return ret;
bf4994d7	499	}
26b3c01f AV	500
26b3c01f AV	501	device_set_wakeup_capable(&client->dev, 1);
bf4994d7 SW	502	}
bf4994d7 SW	503
c11af813	504	ds1374->rtc->ops = &ds1374_rtc_ops;
4136ff3a	505	ds1374->rtc->range_max = U32_MAX;
c11af813	506
fdcfd854	507	ret = devm_rtc_register_device(ds1374->rtc);
c11af813 AB	508	if (ret)
c11af813 AB	509	return ret;
bf4994d7	510
920f91e5	511	#ifdef CONFIG_RTC_DRV_DS1374_WDT
d3de4beb JCC	512	ds1374->wdt.info = &ds1374_wdt_info;
	513	ds1374->wdt.ops = &ds1374_wdt_ops;
	514	ds1374->wdt.timeout = TIMER_MARGIN_DEFAULT;
	515	ds1374->wdt.min_timeout = TIMER_MARGIN_MIN;
	516	ds1374->wdt.max_timeout = TIMER_MARGIN_MAX;
	517
	518	watchdog_init_timeout(&ds1374->wdt, wdt_margin, &client->dev);
	519	watchdog_set_nowayout(&ds1374->wdt, nowayout);
	520	watchdog_stop_on_reboot(&ds1374->wdt);
	521	watchdog_stop_on_unregister(&ds1374->wdt);
	522	watchdog_set_drvdata(&ds1374->wdt, ds1374);
	523	ds1374_wdt_settimeout(&ds1374->wdt, ds1374->wdt.timeout);
	524
	525	ret = devm_watchdog_register_device(&client->dev, &ds1374->wdt);
920f91e5 SA	526	if (ret)
920f91e5 SA	527	return ret;
920f91e5 SA	528	#endif
920f91e5 SA	529
bf4994d7	530	return 0;
bf4994d7 SW	531	}
bf4994d7 SW	532
ed5c2f5f	533	static void ds1374_remove(struct i2c_client *client)
bf4994d7 SW	534	{
	535	struct ds1374 *ds1374 = i2c_get_clientdata(client);
	536
b42f9317	537	if (client->irq > 0) {
bf4994d7 SW	538	mutex_lock(&ds1374->mutex);
	539	ds1374->exiting = 1;
	540	mutex_unlock(&ds1374->mutex);
	541
d1a96639	542	devm_free_irq(&client->dev, client->irq, client);
9db8995b	543	cancel_work_sync(&ds1374->work);
bf4994d7	544	}
bf4994d7 SW	545	}
bf4994d7 SW	546
8b80ef64	547	#ifdef CONFIG_PM_SLEEP
bc96ba74	548	static int ds1374_suspend(struct device *dev)
986e36a5	549	{
bc96ba74 MB	550	struct i2c_client *client = to_i2c_client(dev);
bc96ba74 MB	551
0d9030a2	552	if (client->irq > 0 && device_may_wakeup(&client->dev))
986e36a5 MP	553	enable_irq_wake(client->irq);
	554	return 0;
	555	}
	556
bc96ba74	557	static int ds1374_resume(struct device *dev)
986e36a5	558	{
bc96ba74 MB	559	struct i2c_client *client = to_i2c_client(dev);
bc96ba74 MB	560
0d9030a2	561	if (client->irq > 0 && device_may_wakeup(&client->dev))
986e36a5 MP	562	disable_irq_wake(client->irq);
	563	return 0;
	564	}
8b80ef64	565	#endif
bc96ba74 MB	566
	567	static SIMPLE_DEV_PM_OPS(ds1374_pm, ds1374_suspend, ds1374_resume);
	568
bf4994d7 SW	569	static struct i2c_driver ds1374_driver = {
	570	.driver = {
	571	.name = "rtc-ds1374",
abac12e1	572	.of_match_table = of_match_ptr(ds1374_of_match),
8b80ef64	573	.pm = &ds1374_pm,
bf4994d7	574	},
3f4a3322	575	.probe_new = ds1374_probe,
5a167f45	576	.remove = ds1374_remove,
3760f736	577	.id_table = ds1374_id,
bf4994d7 SW	578	};
bf4994d7 SW	579
0abc9201	580	module_i2c_driver(ds1374_driver);
bf4994d7 SW	581
	582	MODULE_AUTHOR("Scott Wood <scottwood@freescale.com>");
	583	MODULE_DESCRIPTION("Maxim/Dallas DS1374 RTC Driver");
	584	MODULE_LICENSE("GPL");