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

/* rtc-ds1343.c
 *
 * Driver for Dallas Semiconductor DS1343 Low Current, SPI Compatible
 * Real Time Clock
 *
 * Author : Raghavendra Chandra Ganiga <ravi23ganiga@gmail.com>
 *	    Ankur Srivastava <sankurece@gmail.com> : DS1343 Nvram Support
 *
 * 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/init.h>
#include <linux/module.h>
#include <linux/interrupt.h>
#include <linux/device.h>
#include <linux/spi/spi.h>
#include <linux/regmap.h>
#include <linux/rtc.h>
#include <linux/bcd.h>
#include <linux/pm.h>
#include <linux/pm_wakeirq.h>
#include <linux/slab.h>

#define DALLAS_MAXIM_DS1343	0
#define DALLAS_MAXIM_DS1344	1

/* RTC DS1343 Registers */
#define DS1343_SECONDS_REG	0x00
#define DS1343_MINUTES_REG	0x01
#define DS1343_HOURS_REG	0x02
#define DS1343_DAY_REG		0x03
#define DS1343_DATE_REG		0x04
#define DS1343_MONTH_REG	0x05
#define DS1343_YEAR_REG		0x06
#define DS1343_ALM0_SEC_REG	0x07
#define DS1343_ALM0_MIN_REG	0x08
#define DS1343_ALM0_HOUR_REG	0x09
#define DS1343_ALM0_DAY_REG	0x0A
#define DS1343_ALM1_SEC_REG	0x0B
#define DS1343_ALM1_MIN_REG	0x0C
#define DS1343_ALM1_HOUR_REG	0x0D
#define DS1343_ALM1_DAY_REG	0x0E
#define DS1343_CONTROL_REG	0x0F
#define DS1343_STATUS_REG	0x10
#define DS1343_TRICKLE_REG	0x11
#define DS1343_NVRAM		0x20

#define DS1343_NVRAM_LEN	96

/* DS1343 Control Registers bits */
#define DS1343_EOSC		0x80
#define DS1343_DOSF		0x20
#define DS1343_EGFIL		0x10
#define DS1343_SQW		0x08
#define DS1343_INTCN		0x04
#define DS1343_A1IE		0x02
#define DS1343_A0IE		0x01

/* DS1343 Status Registers bits */
#define DS1343_OSF		0x80
#define DS1343_IRQF1		0x02
#define DS1343_IRQF0		0x01

/* DS1343 Trickle Charger Registers bits */
#define DS1343_TRICKLE_MAGIC	0xa0
#define DS1343_TRICKLE_DS1	0x08
#define DS1343_TRICKLE_1K	0x01
#define DS1343_TRICKLE_2K	0x02
#define DS1343_TRICKLE_4K	0x03

static const struct spi_device_id ds1343_id[] = {
	{ "ds1343", DALLAS_MAXIM_DS1343 },
	{ "ds1344", DALLAS_MAXIM_DS1344 },
	{ }
};
MODULE_DEVICE_TABLE(spi, ds1343_id);

struct ds1343_priv {
	struct spi_device *spi;
	struct rtc_device *rtc;
	struct regmap *map;
	struct mutex mutex;
	unsigned int irqen;
	int irq;
	int alarm_sec;
	int alarm_min;
	int alarm_hour;
	int alarm_mday;
};

static int ds1343_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
{
	switch (cmd) {
#ifdef RTC_SET_CHARGE
	case RTC_SET_CHARGE:
	{
		int val;

		if (copy_from_user(&val, (int __user *)arg, sizeof(int)))
			return -EFAULT;

		return regmap_write(priv->map, DS1343_TRICKLE_REG, val);
	}
	break;
#endif
	}

	return -ENOIOCTLCMD;
}

static ssize_t ds1343_show_glitchfilter(struct device *dev,
				struct device_attribute *attr, char *buf)
{
	struct ds1343_priv *priv = dev_get_drvdata(dev);
	int glitch_filt_status, data;

	regmap_read(priv->map, DS1343_CONTROL_REG, &data);

	glitch_filt_status = !!(data & DS1343_EGFIL);

	if (glitch_filt_status)
		return sprintf(buf, "enabled\n");
	else
		return sprintf(buf, "disabled\n");
}

static ssize_t ds1343_store_glitchfilter(struct device *dev,
					struct device_attribute *attr,
					const char *buf, size_t count)
{
	struct ds1343_priv *priv = dev_get_drvdata(dev);
	int data;

	regmap_read(priv->map, DS1343_CONTROL_REG, &data);

	if (strncmp(buf, "enabled", 7) == 0)
		data |= DS1343_EGFIL;

	else if (strncmp(buf, "disabled", 8) == 0)
		data &= ~(DS1343_EGFIL);

	else
		return -EINVAL;

	regmap_write(priv->map, DS1343_CONTROL_REG, data);

	return count;
}

static DEVICE_ATTR(glitch_filter, S_IRUGO | S_IWUSR, ds1343_show_glitchfilter,
			ds1343_store_glitchfilter);

static ssize_t ds1343_nvram_write(struct file *filp, struct kobject *kobj,
			struct bin_attribute *attr,
			char *buf, loff_t off, size_t count)
{
	int ret;
	unsigned char address;
	struct device *dev = kobj_to_dev(kobj);
	struct ds1343_priv *priv = dev_get_drvdata(dev);

	address = DS1343_NVRAM + off;

	ret = regmap_bulk_write(priv->map, address, buf, count);
	if (ret < 0)
		dev_err(&priv->spi->dev, "Error in nvram write %d", ret);

	return (ret < 0) ? ret : count;
}


static ssize_t ds1343_nvram_read(struct file *filp, struct kobject *kobj,
				struct bin_attribute *attr,
				char *buf, loff_t off, size_t count)
{
	int ret;
	unsigned char address;
	struct device *dev = kobj_to_dev(kobj);
	struct ds1343_priv *priv = dev_get_drvdata(dev);

	address = DS1343_NVRAM + off;

	ret = regmap_bulk_read(priv->map, address, buf, count);
	if (ret < 0)
		dev_err(&priv->spi->dev, "Error in nvram read %d\n", ret);

	return (ret < 0) ? ret : count;
}


static struct bin_attribute nvram_attr = {
	.attr.name	= "nvram",
	.attr.mode	= S_IRUGO | S_IWUSR,
	.read		= ds1343_nvram_read,
	.write		= ds1343_nvram_write,
	.size		= DS1343_NVRAM_LEN,
};

static ssize_t ds1343_show_alarmstatus(struct device *dev,
				struct device_attribute *attr, char *buf)
{
	struct ds1343_priv *priv = dev_get_drvdata(dev);
	int alarmstatus, data;

	regmap_read(priv->map, DS1343_CONTROL_REG, &data);

	alarmstatus = !!(data & DS1343_A0IE);

	if (alarmstatus)
		return sprintf(buf, "enabled\n");
	else
		return sprintf(buf, "disabled\n");
}

static DEVICE_ATTR(alarm_status, S_IRUGO, ds1343_show_alarmstatus, NULL);

static ssize_t ds1343_show_alarmmode(struct device *dev,
				struct device_attribute *attr, char *buf)
{
	struct ds1343_priv *priv = dev_get_drvdata(dev);
	int alarm_mode, data;
	char *alarm_str;

	regmap_read(priv->map, DS1343_ALM0_SEC_REG, &data);
	alarm_mode = (data & 0x80) >> 4;

	regmap_read(priv->map, DS1343_ALM0_MIN_REG, &data);
	alarm_mode |= (data & 0x80) >> 5;

	regmap_read(priv->map, DS1343_ALM0_HOUR_REG, &data);
	alarm_mode |= (data & 0x80) >> 6;

	regmap_read(priv->map, DS1343_ALM0_DAY_REG, &data);
	alarm_mode |= (data & 0x80) >> 7;

	switch (alarm_mode) {
	case 15:
		alarm_str = "each second";
		break;

	case 7:
		alarm_str = "seconds match";
		break;

	case 3:
		alarm_str = "minutes and seconds match";
		break;

	case 1:
		alarm_str = "hours, minutes and seconds match";
		break;

	case 0:
		alarm_str = "day, hours, minutes and seconds match";
		break;

	default:
		alarm_str = "invalid";
		break;
	}

	return sprintf(buf, "%s\n", alarm_str);
}

static DEVICE_ATTR(alarm_mode, S_IRUGO, ds1343_show_alarmmode, NULL);

static ssize_t ds1343_show_tricklecharger(struct device *dev,
				struct device_attribute *attr, char *buf)
{
	struct ds1343_priv *priv = dev_get_drvdata(dev);
	int data;
	char *diodes = "disabled", *resistors = " ";

	regmap_read(priv->map, DS1343_TRICKLE_REG, &data);

	if ((data & 0xf0) == DS1343_TRICKLE_MAGIC) {
		switch (data & 0x0c) {
		case DS1343_TRICKLE_DS1:
			diodes = "one diode,";
			break;

		default:
			diodes = "no diode,";
			break;
		}

		switch (data & 0x03) {
		case DS1343_TRICKLE_1K:
			resistors = "1k Ohm";
			break;

		case DS1343_TRICKLE_2K:
			resistors = "2k Ohm";
			break;

		case DS1343_TRICKLE_4K:
			resistors = "4k Ohm";
			break;

		default:
			diodes = "disabled";
			break;
		}
	}

	return sprintf(buf, "%s %s\n", diodes, resistors);
}

static DEVICE_ATTR(trickle_charger, S_IRUGO, ds1343_show_tricklecharger, NULL);

static int ds1343_sysfs_register(struct device *dev)
{
	struct ds1343_priv *priv = dev_get_drvdata(dev);
	int err;

	err = device_create_file(dev, &dev_attr_glitch_filter);
	if (err)
		return err;

	err = device_create_file(dev, &dev_attr_trickle_charger);
	if (err)
		goto error1;

	err = device_create_bin_file(dev, &nvram_attr);
	if (err)
		goto error2;

	if (priv->irq <= 0)
		return err;

	err = device_create_file(dev, &dev_attr_alarm_mode);
	if (err)
		goto error3;

	err = device_create_file(dev, &dev_attr_alarm_status);
	if (!err)
		return err;

	device_remove_file(dev, &dev_attr_alarm_mode);

error3:
	device_remove_bin_file(dev, &nvram_attr);

error2:
	device_remove_file(dev, &dev_attr_trickle_charger);

error1:
	device_remove_file(dev, &dev_attr_glitch_filter);

	return err;
}

static void ds1343_sysfs_unregister(struct device *dev)
{
	struct ds1343_priv *priv = dev_get_drvdata(dev);

	device_remove_file(dev, &dev_attr_glitch_filter);
	device_remove_file(dev, &dev_attr_trickle_charger);
	device_remove_bin_file(dev, &nvram_attr);

	if (priv->irq <= 0)
		return;

	device_remove_file(dev, &dev_attr_alarm_status);
	device_remove_file(dev, &dev_attr_alarm_mode);
}

static int ds1343_read_time(struct device *dev, struct rtc_time *dt)
{
	struct ds1343_priv *priv = dev_get_drvdata(dev);
	unsigned char buf[7];
	int res;

	res = regmap_bulk_read(priv->map, DS1343_SECONDS_REG, buf, 7);
	if (res)
		return res;

	dt->tm_sec	= bcd2bin(buf[0]);
	dt->tm_min	= bcd2bin(buf[1]);
	dt->tm_hour	= bcd2bin(buf[2] & 0x3F);
	dt->tm_wday	= bcd2bin(buf[3]) - 1;
	dt->tm_mday	= bcd2bin(buf[4]);
	dt->tm_mon	= bcd2bin(buf[5] & 0x1F) - 1;
	dt->tm_year	= bcd2bin(buf[6]) + 100; /* year offset from 1900 */

	return rtc_valid_tm(dt);
}

static int ds1343_set_time(struct device *dev, struct rtc_time *dt)
{
	struct ds1343_priv *priv = dev_get_drvdata(dev);
	int res;

	res = regmap_write(priv->map, DS1343_SECONDS_REG,
				bin2bcd(dt->tm_sec));
	if (res)
		return res;

	res = regmap_write(priv->map, DS1343_MINUTES_REG,
				bin2bcd(dt->tm_min));
	if (res)
		return res;

	res = regmap_write(priv->map, DS1343_HOURS_REG,
				bin2bcd(dt->tm_hour) & 0x3F);
	if (res)
		return res;

	res = regmap_write(priv->map, DS1343_DAY_REG,
				bin2bcd(dt->tm_wday + 1));
	if (res)
		return res;

	res = regmap_write(priv->map, DS1343_DATE_REG,
				bin2bcd(dt->tm_mday));
	if (res)
		return res;

	res = regmap_write(priv->map, DS1343_MONTH_REG,
				bin2bcd(dt->tm_mon + 1));
	if (res)
		return res;

	dt->tm_year %= 100;

	res = regmap_write(priv->map, DS1343_YEAR_REG,
				bin2bcd(dt->tm_year));
	if (res)
		return res;

	return 0;
}

static int ds1343_update_alarm(struct device *dev)
{
	struct ds1343_priv *priv = dev_get_drvdata(dev);
	unsigned int control, stat;
	unsigned char buf[4];
	int res = 0;

	res = regmap_read(priv->map, DS1343_CONTROL_REG, &control);
	if (res)
		return res;

	res = regmap_read(priv->map, DS1343_STATUS_REG, &stat);
	if (res)
		return res;

	control &= ~(DS1343_A0IE);
	stat &= ~(DS1343_IRQF0);

	res = regmap_write(priv->map, DS1343_CONTROL_REG, control);
	if (res)
		return res;

	res = regmap_write(priv->map, DS1343_STATUS_REG, stat);
	if (res)
		return res;

	buf[0] = priv->alarm_sec < 0 || (priv->irqen & RTC_UF) ?
		0x80 : bin2bcd(priv->alarm_sec) & 0x7F;
	buf[1] = priv->alarm_min < 0 || (priv->irqen & RTC_UF) ?
		0x80 : bin2bcd(priv->alarm_min) & 0x7F;
	buf[2] = priv->alarm_hour < 0 || (priv->irqen & RTC_UF) ?
		0x80 : bin2bcd(priv->alarm_hour) & 0x3F;
	buf[3] = priv->alarm_mday < 0 || (priv->irqen & RTC_UF) ?
		0x80 : bin2bcd(priv->alarm_mday) & 0x7F;

	res = regmap_bulk_write(priv->map, DS1343_ALM0_SEC_REG, buf, 4);
	if (res)
		return res;

	if (priv->irqen) {
		control |= DS1343_A0IE;
		res = regmap_write(priv->map, DS1343_CONTROL_REG, control);
	}

	return res;
}

static int ds1343_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
{
	struct ds1343_priv *priv = dev_get_drvdata(dev);
	int res = 0;
	unsigned int stat;

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

	mutex_lock(&priv->mutex);

	res = regmap_read(priv->map, DS1343_STATUS_REG, &stat);
	if (res)
		goto out;

	alarm->enabled = !!(priv->irqen & RTC_AF);
	alarm->pending = !!(stat & DS1343_IRQF0);

	alarm->time.tm_sec = priv->alarm_sec < 0 ? 0 : priv->alarm_sec;
	alarm->time.tm_min = priv->alarm_min < 0 ? 0 : priv->alarm_min;
	alarm->time.tm_hour = priv->alarm_hour < 0 ? 0 : priv->alarm_hour;
	alarm->time.tm_mday = priv->alarm_mday < 0 ? 0 : priv->alarm_mday;

	alarm->time.tm_mon = -1;
	alarm->time.tm_year = -1;
	alarm->time.tm_wday = -1;
	alarm->time.tm_yday = -1;
	alarm->time.tm_isdst = -1;

out:
	mutex_unlock(&priv->mutex);
	return res;
}

static int ds1343_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
{
	struct ds1343_priv *priv = dev_get_drvdata(dev);
	int res = 0;

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

	mutex_lock(&priv->mutex);

	priv->alarm_sec = alarm->time.tm_sec;
	priv->alarm_min = alarm->time.tm_min;
	priv->alarm_hour = alarm->time.tm_hour;
	priv->alarm_mday = alarm->time.tm_mday;

	if (alarm->enabled)
		priv->irqen |= RTC_AF;

	res = ds1343_update_alarm(dev);

	mutex_unlock(&priv->mutex);

	return res;
}

static int ds1343_alarm_irq_enable(struct device *dev, unsigned int enabled)
{
	struct ds1343_priv *priv = dev_get_drvdata(dev);
	int res = 0;

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

	mutex_lock(&priv->mutex);

	if (enabled)
		priv->irqen |= RTC_AF;
	else
		priv->irqen &= ~RTC_AF;

	res = ds1343_update_alarm(dev);

	mutex_unlock(&priv->mutex);

	return res;
}

static irqreturn_t ds1343_thread(int irq, void *dev_id)
{
	struct ds1343_priv *priv = dev_id;
	unsigned int stat, control;
	int res = 0;

	mutex_lock(&priv->mutex);

	res = regmap_read(priv->map, DS1343_STATUS_REG, &stat);
	if (res)
		goto out;

	if (stat & DS1343_IRQF0) {
		stat &= ~DS1343_IRQF0;
		regmap_write(priv->map, DS1343_STATUS_REG, stat);

		res = regmap_read(priv->map, DS1343_CONTROL_REG, &control);
		if (res)
			goto out;

		control &= ~DS1343_A0IE;
		regmap_write(priv->map, DS1343_CONTROL_REG, control);

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

out:
	mutex_unlock(&priv->mutex);
	return IRQ_HANDLED;
}

static const struct rtc_class_ops ds1343_rtc_ops = {
	.ioctl		= ds1343_ioctl,
	.read_time	= ds1343_read_time,
	.set_time	= ds1343_set_time,
	.read_alarm	= ds1343_read_alarm,
	.set_alarm	= ds1343_set_alarm,
	.alarm_irq_enable = ds1343_alarm_irq_enable,
};

static int ds1343_probe(struct spi_device *spi)
{
	struct ds1343_priv *priv;
	struct regmap_config config;
	unsigned int data;
	int res;

	memset(&config, 0, sizeof(config));
	config.reg_bits = 8;
	config.val_bits = 8;
	config.write_flag_mask = 0x80;

	priv = devm_kzalloc(&spi->dev, sizeof(struct ds1343_priv), GFP_KERNEL);
	if (!priv)
		return -ENOMEM;

	priv->spi = spi;
	mutex_init(&priv->mutex);

	/* RTC DS1347 works in spi mode 3 and
	 * its chip select is active high
	 */
	spi->mode = SPI_MODE_3 | SPI_CS_HIGH;
	spi->bits_per_word = 8;
	res = spi_setup(spi);
	if (res)
		return res;

	spi_set_drvdata(spi, priv);

	priv->map = devm_regmap_init_spi(spi, &config);

	if (IS_ERR(priv->map)) {
		dev_err(&spi->dev, "spi regmap init failed for rtc ds1343\n");
		return PTR_ERR(priv->map);
	}

	res = regmap_read(priv->map, DS1343_SECONDS_REG, &data);
	if (res)
		return res;

	regmap_read(priv->map, DS1343_CONTROL_REG, &data);
	data |= DS1343_INTCN;
	data &= ~(DS1343_EOSC | DS1343_A1IE | DS1343_A0IE);
	regmap_write(priv->map, DS1343_CONTROL_REG, data);

	regmap_read(priv->map, DS1343_STATUS_REG, &data);
	data &= ~(DS1343_OSF | DS1343_IRQF1 | DS1343_IRQF0);
	regmap_write(priv->map, DS1343_STATUS_REG, data);

	priv->rtc = devm_rtc_device_register(&spi->dev, "ds1343",
					&ds1343_rtc_ops, THIS_MODULE);
	if (IS_ERR(priv->rtc)) {
		dev_err(&spi->dev, "unable to register rtc ds1343\n");
		return PTR_ERR(priv->rtc);
	}

	priv->irq = spi->irq;

	if (priv->irq >= 0) {
		res = devm_request_threaded_irq(&spi->dev, spi->irq, NULL,
						ds1343_thread, IRQF_ONESHOT,
						"ds1343", priv);
		if (res) {
			priv->irq = -1;
			dev_err(&spi->dev,
				"unable to request irq for rtc ds1343\n");
		} else {
			device_init_wakeup(&spi->dev, true);
			dev_pm_set_wake_irq(&spi->dev, spi->irq);
		}
	}

	res = ds1343_sysfs_register(&spi->dev);
	if (res)
		dev_err(&spi->dev,
			"unable to create sysfs entries for rtc ds1343\n");

	return 0;
}

static int ds1343_remove(struct spi_device *spi)
{
	struct ds1343_priv *priv = spi_get_drvdata(spi);

	if (spi->irq) {
		mutex_lock(&priv->mutex);
		priv->irqen &= ~RTC_AF;
		mutex_unlock(&priv->mutex);

		dev_pm_clear_wake_irq(&spi->dev);
		device_init_wakeup(&spi->dev, false);
		devm_free_irq(&spi->dev, spi->irq, priv);
	}

	spi_set_drvdata(spi, NULL);

	ds1343_sysfs_unregister(&spi->dev);

	return 0;
}

#ifdef CONFIG_PM_SLEEP

static int ds1343_suspend(struct device *dev)
{
	struct spi_device *spi = to_spi_device(dev);

	if (spi->irq >= 0 && device_may_wakeup(dev))
		enable_irq_wake(spi->irq);

	return 0;
}

static int ds1343_resume(struct device *dev)
{
	struct spi_device *spi = to_spi_device(dev);

	if (spi->irq >= 0 && device_may_wakeup(dev))
		disable_irq_wake(spi->irq);

	return 0;
}

#endif

static SIMPLE_DEV_PM_OPS(ds1343_pm, ds1343_suspend, ds1343_resume);

static struct spi_driver ds1343_driver = {
	.driver = {
		.name = "ds1343",
		.pm = &ds1343_pm,
	},
	.probe = ds1343_probe,
	.remove = ds1343_remove,
	.id_table = ds1343_id,
};

module_spi_driver(ds1343_driver);

MODULE_DESCRIPTION("DS1343 RTC SPI Driver");
MODULE_AUTHOR("Raghavendra Chandra Ganiga <ravi23ganiga@gmail.com>,"
		"Ankur Srivastava <sankurece@gmail.com>");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
1d6316f5 RG	1	/* rtc-ds1343.c
	2	*
	3	* Driver for Dallas Semiconductor DS1343 Low Current, SPI Compatible
	4	* Real Time Clock
	5	*
	6	* Author : Raghavendra Chandra Ganiga <ravi23ganiga@gmail.com>
571eb883	7	* Ankur Srivastava <sankurece@gmail.com> : DS1343 Nvram Support
1d6316f5 RG	8	*
	9	* This program is free software; you can redistribute it and/or modify
	10	* it under the terms of the GNU General Public License version 2 as
	11	* published by the Free Software Foundation.
	12	*
	13	*/
	14
	15	#include <linux/init.h>
	16	#include <linux/module.h>
	17	#include <linux/interrupt.h>
	18	#include <linux/device.h>
	19	#include <linux/spi/spi.h>
	20	#include <linux/regmap.h>
	21	#include <linux/rtc.h>
	22	#include <linux/bcd.h>
	23	#include <linux/pm.h>
caff0cc4	24	#include <linux/pm_wakeirq.h>
1d6316f5 RG	25	#include <linux/slab.h>
1d6316f5 RG	26
1d6316f5 RG	27	#define DALLAS_MAXIM_DS1343 0
	28	#define DALLAS_MAXIM_DS1344 1
	29
	30	/* RTC DS1343 Registers */
	31	#define DS1343_SECONDS_REG 0x00
	32	#define DS1343_MINUTES_REG 0x01
	33	#define DS1343_HOURS_REG 0x02
	34	#define DS1343_DAY_REG 0x03
	35	#define DS1343_DATE_REG 0x04
	36	#define DS1343_MONTH_REG 0x05
	37	#define DS1343_YEAR_REG 0x06
	38	#define DS1343_ALM0_SEC_REG 0x07
	39	#define DS1343_ALM0_MIN_REG 0x08
	40	#define DS1343_ALM0_HOUR_REG 0x09
	41	#define DS1343_ALM0_DAY_REG 0x0A
	42	#define DS1343_ALM1_SEC_REG 0x0B
	43	#define DS1343_ALM1_MIN_REG 0x0C
	44	#define DS1343_ALM1_HOUR_REG 0x0D
	45	#define DS1343_ALM1_DAY_REG 0x0E
	46	#define DS1343_CONTROL_REG 0x0F
	47	#define DS1343_STATUS_REG 0x10
	48	#define DS1343_TRICKLE_REG 0x11
571eb883 RG	49	#define DS1343_NVRAM 0x20
	50
	51	#define DS1343_NVRAM_LEN 96
1d6316f5 RG	52
	53	/* DS1343 Control Registers bits */
	54	#define DS1343_EOSC 0x80
	55	#define DS1343_DOSF 0x20
	56	#define DS1343_EGFIL 0x10
	57	#define DS1343_SQW 0x08
	58	#define DS1343_INTCN 0x04
	59	#define DS1343_A1IE 0x02
	60	#define DS1343_A0IE 0x01
	61
	62	/* DS1343 Status Registers bits */
	63	#define DS1343_OSF 0x80
	64	#define DS1343_IRQF1 0x02
	65	#define DS1343_IRQF0 0x01
	66
	67	/* DS1343 Trickle Charger Registers bits */
	68	#define DS1343_TRICKLE_MAGIC 0xa0
	69	#define DS1343_TRICKLE_DS1 0x08
	70	#define DS1343_TRICKLE_1K 0x01
	71	#define DS1343_TRICKLE_2K 0x02
	72	#define DS1343_TRICKLE_4K 0x03
	73
	74	static const struct spi_device_id ds1343_id[] = {
	75	{ "ds1343", DALLAS_MAXIM_DS1343 },
	76	{ "ds1344", DALLAS_MAXIM_DS1344 },
	77	{ }
	78	};
	79	MODULE_DEVICE_TABLE(spi, ds1343_id);
	80
	81	struct ds1343_priv {
	82	struct spi_device *spi;
	83	struct rtc_device *rtc;
	84	struct regmap *map;
	85	struct mutex mutex;
	86	unsigned int irqen;
10b06b87	87	int irq;
1d6316f5 RG	88	int alarm_sec;
	89	int alarm_min;
	90	int alarm_hour;
	91	int alarm_mday;
	92	};
	93
	94	static int ds1343_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
	95	{
	96	switch (cmd) {
	97	#ifdef RTC_SET_CHARGE
	98	case RTC_SET_CHARGE:
	99	{
	100	int val;
	101
	102	if (copy_from_user(&val, (int __user *)arg, sizeof(int)))
	103	return -EFAULT;
	104
	105	return regmap_write(priv->map, DS1343_TRICKLE_REG, val);
	106	}
	107	break;
	108	#endif
	109	}
	110
	111	return -ENOIOCTLCMD;
	112	}
	113
	114	static ssize_t ds1343_show_glitchfilter(struct device *dev,
	115	struct device_attribute attr, char buf)
	116	{
	117	struct ds1343_priv *priv = dev_get_drvdata(dev);
	118	int glitch_filt_status, data;
	119
	120	regmap_read(priv->map, DS1343_CONTROL_REG, &data);
	121
	122	glitch_filt_status = !!(data & DS1343_EGFIL);
	123
	124	if (glitch_filt_status)
	125	return sprintf(buf, "enabled\n");
	126	else
	127	return sprintf(buf, "disabled\n");
	128	}
	129
	130	static ssize_t ds1343_store_glitchfilter(struct device *dev,
	131	struct device_attribute *attr,
	132	const char *buf, size_t count)
	133	{
	134	struct ds1343_priv *priv = dev_get_drvdata(dev);
	135	int data;
	136
	137	regmap_read(priv->map, DS1343_CONTROL_REG, &data);
	138
	139	if (strncmp(buf, "enabled", 7) == 0)
	140	data \|= DS1343_EGFIL;
	141
	142	else if (strncmp(buf, "disabled", 8) == 0)
	143	data &= ~(DS1343_EGFIL);
	144
	145	else
	146	return -EINVAL;
	147
	148	regmap_write(priv->map, DS1343_CONTROL_REG, data);
	149
	150	return count;
	151	}
152
153	static DEVICE_ATTR(glitch_filter, S_IRUGO \| S_IWUSR, ds1343_show_glitchfilter,
154	ds1343_store_glitchfilter);
155
571eb883 RG	156	static ssize_t ds1343_nvram_write(struct file filp, struct kobject kobj,
	157	struct bin_attribute *attr,
	158	char *buf, loff_t off, size_t count)
	159	{
	160	int ret;
	161	unsigned char address;
	162	struct device *dev = kobj_to_dev(kobj);
	163	struct ds1343_priv *priv = dev_get_drvdata(dev);
	164
571eb883 RG	165	address = DS1343_NVRAM + off;
	166
	167	ret = regmap_bulk_write(priv->map, address, buf, count);
	168	if (ret < 0)
	169	dev_err(&priv->spi->dev, "Error in nvram write %d", ret);
	170
	171	return (ret < 0) ? ret : count;
	172	}
	173
	174
	175	static ssize_t ds1343_nvram_read(struct file filp, struct kobject kobj,
	176	struct bin_attribute *attr,
	177	char *buf, loff_t off, size_t count)
	178	{
	179	int ret;
	180	unsigned char address;
	181	struct device *dev = kobj_to_dev(kobj);
	182	struct ds1343_priv *priv = dev_get_drvdata(dev);
	183
571eb883 RG	184	address = DS1343_NVRAM + off;
	185
	186	ret = regmap_bulk_read(priv->map, address, buf, count);
	187	if (ret < 0)
	188	dev_err(&priv->spi->dev, "Error in nvram read %d\n", ret);
	189
	190	return (ret < 0) ? ret : count;
	191	}
	192
	193
	194	static struct bin_attribute nvram_attr = {
	195	.attr.name = "nvram",
	196	.attr.mode = S_IRUGO \| S_IWUSR,
	197	.read = ds1343_nvram_read,
	198	.write = ds1343_nvram_write,
	199	.size = DS1343_NVRAM_LEN,
	200	};
	201
1d6316f5 RG	202	static ssize_t ds1343_show_alarmstatus(struct device *dev,
	203	struct device_attribute attr, char buf)
	204	{
	205	struct ds1343_priv *priv = dev_get_drvdata(dev);
	206	int alarmstatus, data;
	207
	208	regmap_read(priv->map, DS1343_CONTROL_REG, &data);
	209
	210	alarmstatus = !!(data & DS1343_A0IE);
	211
	212	if (alarmstatus)
	213	return sprintf(buf, "enabled\n");
	214	else
	215	return sprintf(buf, "disabled\n");
	216	}
	217
	218	static DEVICE_ATTR(alarm_status, S_IRUGO, ds1343_show_alarmstatus, NULL);
	219
	220	static ssize_t ds1343_show_alarmmode(struct device *dev,
	221	struct device_attribute attr, char buf)
	222	{
	223	struct ds1343_priv *priv = dev_get_drvdata(dev);
	224	int alarm_mode, data;
	225	char *alarm_str;
	226
	227	regmap_read(priv->map, DS1343_ALM0_SEC_REG, &data);
	228	alarm_mode = (data & 0x80) >> 4;
	229
	230	regmap_read(priv->map, DS1343_ALM0_MIN_REG, &data);
	231	alarm_mode \|= (data & 0x80) >> 5;
	232
	233	regmap_read(priv->map, DS1343_ALM0_HOUR_REG, &data);
	234	alarm_mode \|= (data & 0x80) >> 6;
	235
	236	regmap_read(priv->map, DS1343_ALM0_DAY_REG, &data);
	237	alarm_mode \|= (data & 0x80) >> 7;
	238
	239	switch (alarm_mode) {
	240	case 15:
	241	alarm_str = "each second";
	242	break;
	243
	244	case 7:
	245	alarm_str = "seconds match";
	246	break;
	247
	248	case 3:
	249	alarm_str = "minutes and seconds match";
	250	break;
	251
	252	case 1:
	253	alarm_str = "hours, minutes and seconds match";
	254	break;
	255
	256	case 0:
	257	alarm_str = "day, hours, minutes and seconds match";
	258	break;
	259
	260	default:
	261	alarm_str = "invalid";
	262	break;
	263	}
	264
	265	return sprintf(buf, "%s\n", alarm_str);
266	}
267
268	static DEVICE_ATTR(alarm_mode, S_IRUGO, ds1343_show_alarmmode, NULL);
269
270	static ssize_t ds1343_show_tricklecharger(struct device *dev,
271	struct device_attribute attr, char buf)
272	{
273	struct ds1343_priv *priv = dev_get_drvdata(dev);
274	int data;
275	char diodes = "disabled", resistors = " ";
276
277	regmap_read(priv->map, DS1343_TRICKLE_REG, &data);
278
279	if ((data & 0xf0) == DS1343_TRICKLE_MAGIC) {
280	switch (data & 0x0c) {
281	case DS1343_TRICKLE_DS1:
282	diodes = "one diode,";
283	break;
284
285	default:
286	diodes = "no diode,";
287	break;
288	}
289
290	switch (data & 0x03) {
291	case DS1343_TRICKLE_1K:
292	resistors = "1k Ohm";
293	break;
294
295	case DS1343_TRICKLE_2K:
296	resistors = "2k Ohm";
297	break;
298
299	case DS1343_TRICKLE_4K:
300	resistors = "4k Ohm";
301	break;
302
303	default:
304	diodes = "disabled";
305	break;
306	}
307	}
308
309	return sprintf(buf, "%s %s\n", diodes, resistors);
310	}
311
312	static DEVICE_ATTR(trickle_charger, S_IRUGO, ds1343_show_tricklecharger, NULL);
313
314	static int ds1343_sysfs_register(struct device *dev)
315	{
10b06b87	316	struct ds1343_priv *priv = dev_get_drvdata(dev);
1d6316f5 RG	317	int err;
	318
	319	err = device_create_file(dev, &dev_attr_glitch_filter);
	320	if (err)
	321	return err;
	322
10b06b87	323	err = device_create_file(dev, &dev_attr_trickle_charger);
1d6316f5 RG	324	if (err)
	325	goto error1;
	326
571eb883 RG	327	err = device_create_bin_file(dev, &nvram_attr);
	328	if (err)
	329	goto error2;
	330
10b06b87 RG	331	if (priv->irq <= 0)
	332	return err;
	333
1d6316f5 RG	334	err = device_create_file(dev, &dev_attr_alarm_mode);
1d6316f5 RG	335	if (err)
571eb883	336	goto error3;
1d6316f5	337
10b06b87	338	err = device_create_file(dev, &dev_attr_alarm_status);
1d6316f5 RG	339	if (!err)
	340	return err;
	341
	342	device_remove_file(dev, &dev_attr_alarm_mode);
	343
571eb883 RG	344	error3:
	345	device_remove_bin_file(dev, &nvram_attr);
	346
1d6316f5	347	error2:
10b06b87	348	device_remove_file(dev, &dev_attr_trickle_charger);
1d6316f5 RG	349
	350	error1:
	351	device_remove_file(dev, &dev_attr_glitch_filter);
	352
	353	return err;
	354	}
	355
	356	static void ds1343_sysfs_unregister(struct device *dev)
	357	{
10b06b87 RG	358	struct ds1343_priv *priv = dev_get_drvdata(dev);
10b06b87 RG	359
1d6316f5	360	device_remove_file(dev, &dev_attr_glitch_filter);
10b06b87	361	device_remove_file(dev, &dev_attr_trickle_charger);
571eb883	362	device_remove_bin_file(dev, &nvram_attr);
10b06b87 RG	363
	364	if (priv->irq <= 0)
	365	return;
	366
1d6316f5 RG	367	device_remove_file(dev, &dev_attr_alarm_status);
1d6316f5 RG	368	device_remove_file(dev, &dev_attr_alarm_mode);
1d6316f5 RG	369	}
	370
	371	static int ds1343_read_time(struct device dev, struct rtc_time dt)
	372	{
	373	struct ds1343_priv *priv = dev_get_drvdata(dev);
	374	unsigned char buf[7];
	375	int res;
	376
	377	res = regmap_bulk_read(priv->map, DS1343_SECONDS_REG, buf, 7);
	378	if (res)
	379	return res;
	380
	381	dt->tm_sec = bcd2bin(buf[0]);
	382	dt->tm_min = bcd2bin(buf[1]);
	383	dt->tm_hour = bcd2bin(buf[2] & 0x3F);
	384	dt->tm_wday = bcd2bin(buf[3]) - 1;
	385	dt->tm_mday = bcd2bin(buf[4]);
	386	dt->tm_mon = bcd2bin(buf[5] & 0x1F) - 1;
	387	dt->tm_year = bcd2bin(buf[6]) + 100; /* year offset from 1900 */
	388
	389	return rtc_valid_tm(dt);
	390	}
	391
	392	static int ds1343_set_time(struct device dev, struct rtc_time dt)
	393	{
	394	struct ds1343_priv *priv = dev_get_drvdata(dev);
	395	int res;
	396
	397	res = regmap_write(priv->map, DS1343_SECONDS_REG,
	398	bin2bcd(dt->tm_sec));
	399	if (res)
	400	return res;
	401
	402	res = regmap_write(priv->map, DS1343_MINUTES_REG,
	403	bin2bcd(dt->tm_min));
	404	if (res)
	405	return res;
	406
	407	res = regmap_write(priv->map, DS1343_HOURS_REG,
	408	bin2bcd(dt->tm_hour) & 0x3F);
	409	if (res)
	410	return res;
	411
	412	res = regmap_write(priv->map, DS1343_DAY_REG,
	413	bin2bcd(dt->tm_wday + 1));
	414	if (res)
	415	return res;
	416
	417	res = regmap_write(priv->map, DS1343_DATE_REG,
	418	bin2bcd(dt->tm_mday));
	419	if (res)
	420	return res;
	421
	422	res = regmap_write(priv->map, DS1343_MONTH_REG,
	423	bin2bcd(dt->tm_mon + 1));
	424	if (res)
	425	return res;
	426
	427	dt->tm_year %= 100;
	428
	429	res = regmap_write(priv->map, DS1343_YEAR_REG,
	430	bin2bcd(dt->tm_year));
	431	if (res)
	432	return res;
433
434	return 0;
435	}
436
437	static int ds1343_update_alarm(struct device *dev)
438	{
439	struct ds1343_priv *priv = dev_get_drvdata(dev);
440	unsigned int control, stat;
441	unsigned char buf[4];
442	int res = 0;
443
444	res = regmap_read(priv->map, DS1343_CONTROL_REG, &control);
445	if (res)
446	return res;
447
448	res = regmap_read(priv->map, DS1343_STATUS_REG, &stat);
449	if (res)
450	return res;
451
452	control &= ~(DS1343_A0IE);
453	stat &= ~(DS1343_IRQF0);
454
455	res = regmap_write(priv->map, DS1343_CONTROL_REG, control);
456	if (res)
457	return res;
458
459	res = regmap_write(priv->map, DS1343_STATUS_REG, stat);
460	if (res)
461	return res;
462
463	buf[0] = priv->alarm_sec < 0 \|\| (priv->irqen & RTC_UF) ?
464	0x80 : bin2bcd(priv->alarm_sec) & 0x7F;
465	buf[1] = priv->alarm_min < 0 \|\| (priv->irqen & RTC_UF) ?
466	0x80 : bin2bcd(priv->alarm_min) & 0x7F;
467	buf[2] = priv->alarm_hour < 0 \|\| (priv->irqen & RTC_UF) ?
468	0x80 : bin2bcd(priv->alarm_hour) & 0x3F;
469	buf[3] = priv->alarm_mday < 0 \|\| (priv->irqen & RTC_UF) ?
470	0x80 : bin2bcd(priv->alarm_mday) & 0x7F;
471
472	res = regmap_bulk_write(priv->map, DS1343_ALM0_SEC_REG, buf, 4);
473	if (res)
474	return res;
475
476	if (priv->irqen) {
477	control \|= DS1343_A0IE;
478	res = regmap_write(priv->map, DS1343_CONTROL_REG, control);
479	}
480
481	return res;
482	}
483
484	static int ds1343_read_alarm(struct device dev, struct rtc_wkalrm alarm)
485	{
486	struct ds1343_priv *priv = dev_get_drvdata(dev);
1d6316f5 RG	487	int res = 0;
	488	unsigned int stat;
	489
10b06b87	490	if (priv->irq <= 0)
1d6316f5 RG	491	return -EINVAL;
	492
	493	mutex_lock(&priv->mutex);
	494
	495	res = regmap_read(priv->map, DS1343_STATUS_REG, &stat);
	496	if (res)
	497	goto out;
	498
	499	alarm->enabled = !!(priv->irqen & RTC_AF);
	500	alarm->pending = !!(stat & DS1343_IRQF0);
	501
	502	alarm->time.tm_sec = priv->alarm_sec < 0 ? 0 : priv->alarm_sec;
	503	alarm->time.tm_min = priv->alarm_min < 0 ? 0 : priv->alarm_min;
	504	alarm->time.tm_hour = priv->alarm_hour < 0 ? 0 : priv->alarm_hour;
	505	alarm->time.tm_mday = priv->alarm_mday < 0 ? 0 : priv->alarm_mday;
	506
	507	alarm->time.tm_mon = -1;
	508	alarm->time.tm_year = -1;
	509	alarm->time.tm_wday = -1;
	510	alarm->time.tm_yday = -1;
	511	alarm->time.tm_isdst = -1;
	512
	513	out:
	514	mutex_unlock(&priv->mutex);
	515	return res;
	516	}
	517
	518	static int ds1343_set_alarm(struct device dev, struct rtc_wkalrm alarm)
	519	{
	520	struct ds1343_priv *priv = dev_get_drvdata(dev);
1d6316f5 RG	521	int res = 0;
1d6316f5 RG	522
10b06b87	523	if (priv->irq <= 0)
1d6316f5 RG	524	return -EINVAL;
	525
	526	mutex_lock(&priv->mutex);
	527
	528	priv->alarm_sec = alarm->time.tm_sec;
	529	priv->alarm_min = alarm->time.tm_min;
	530	priv->alarm_hour = alarm->time.tm_hour;
	531	priv->alarm_mday = alarm->time.tm_mday;
	532
	533	if (alarm->enabled)
	534	priv->irqen \|= RTC_AF;
	535
	536	res = ds1343_update_alarm(dev);
	537
	538	mutex_unlock(&priv->mutex);
	539
	540	return res;
	541	}
	542
	543	static int ds1343_alarm_irq_enable(struct device *dev, unsigned int enabled)
	544	{
	545	struct ds1343_priv *priv = dev_get_drvdata(dev);
1d6316f5 RG	546	int res = 0;
1d6316f5 RG	547
10b06b87	548	if (priv->irq <= 0)
1d6316f5 RG	549	return -EINVAL;
	550
	551	mutex_lock(&priv->mutex);
	552
	553	if (enabled)
	554	priv->irqen \|= RTC_AF;
	555	else
	556	priv->irqen &= ~RTC_AF;
	557
	558	res = ds1343_update_alarm(dev);
	559
	560	mutex_unlock(&priv->mutex);
	561
	562	return res;
	563	}
	564
	565	static irqreturn_t ds1343_thread(int irq, void *dev_id)
	566	{
	567	struct ds1343_priv *priv = dev_id;
	568	unsigned int stat, control;
	569	int res = 0;
	570
	571	mutex_lock(&priv->mutex);
	572
	573	res = regmap_read(priv->map, DS1343_STATUS_REG, &stat);
	574	if (res)
	575	goto out;
	576
	577	if (stat & DS1343_IRQF0) {
	578	stat &= ~DS1343_IRQF0;
	579	regmap_write(priv->map, DS1343_STATUS_REG, stat);
	580
	581	res = regmap_read(priv->map, DS1343_CONTROL_REG, &control);
	582	if (res)
	583	goto out;
	584
	585	control &= ~DS1343_A0IE;
	586	regmap_write(priv->map, DS1343_CONTROL_REG, control);
	587
	588	rtc_update_irq(priv->rtc, 1, RTC_AF \| RTC_IRQF);
	589	}
	590
	591	out:
	592	mutex_unlock(&priv->mutex);
	593	return IRQ_HANDLED;
	594	}
	595
	596	static const struct rtc_class_ops ds1343_rtc_ops = {
	597	.ioctl = ds1343_ioctl,
	598	.read_time = ds1343_read_time,
	599	.set_time = ds1343_set_time,
	600	.read_alarm = ds1343_read_alarm,
	601	.set_alarm = ds1343_set_alarm,
	602	.alarm_irq_enable = ds1343_alarm_irq_enable,
	603	};
	604
	605	static int ds1343_probe(struct spi_device *spi)
	606	{
	607	struct ds1343_priv *priv;
	608	struct regmap_config config;
	609	unsigned int data;
	610	int res;
	611
	612	memset(&config, 0, sizeof(config));
613	config.reg_bits = 8;
614	config.val_bits = 8;
615	config.write_flag_mask = 0x80;
616
617	priv = devm_kzalloc(&spi->dev, sizeof(struct ds1343_priv), GFP_KERNEL);
618	if (!priv)
619	return -ENOMEM;
620
621	priv->spi = spi;
622	mutex_init(&priv->mutex);
623
624	/* RTC DS1347 works in spi mode 3 and
625	* its chip select is active high
626	*/
627	spi->mode = SPI_MODE_3 \| SPI_CS_HIGH;
628	spi->bits_per_word = 8;
629	res = spi_setup(spi);
630	if (res)
631	return res;
632
633	spi_set_drvdata(spi, priv);
634
635	priv->map = devm_regmap_init_spi(spi, &config);
636
637	if (IS_ERR(priv->map)) {
638	dev_err(&spi->dev, "spi regmap init failed for rtc ds1343\n");
639	return PTR_ERR(priv->map);
640	}
641
642	res = regmap_read(priv->map, DS1343_SECONDS_REG, &data);
643	if (res)
644	return res;
645
646	regmap_read(priv->map, DS1343_CONTROL_REG, &data);
647	data \|= DS1343_INTCN;
648	data &= ~(DS1343_EOSC \| DS1343_A1IE \| DS1343_A0IE);
649	regmap_write(priv->map, DS1343_CONTROL_REG, data);
650
651	regmap_read(priv->map, DS1343_STATUS_REG, &data);
652	data &= ~(DS1343_OSF \| DS1343_IRQF1 \| DS1343_IRQF0);
653	regmap_write(priv->map, DS1343_STATUS_REG, data);
654
655	priv->rtc = devm_rtc_device_register(&spi->dev, "ds1343",
656	&ds1343_rtc_ops, THIS_MODULE);
657	if (IS_ERR(priv->rtc)) {
658	dev_err(&spi->dev, "unable to register rtc ds1343\n");
659	return PTR_ERR(priv->rtc);
660	}
661
10b06b87 RG	662	priv->irq = spi->irq;
	663
	664	if (priv->irq >= 0) {
1d6316f5	665	res = devm_request_threaded_irq(&spi->dev, spi->irq, NULL,
caff0cc4	666	ds1343_thread, IRQF_ONESHOT,
1d6316f5 RG	667	"ds1343", priv);
1d6316f5 RG	668	if (res) {
10b06b87	669	priv->irq = -1;
1d6316f5 RG	670	dev_err(&spi->dev,
1d6316f5 RG	671	"unable to request irq for rtc ds1343\n");
10b06b87	672	} else {
caff0cc4 SH	673	device_init_wakeup(&spi->dev, true);
caff0cc4 SH	674	dev_pm_set_wake_irq(&spi->dev, spi->irq);
1d6316f5	675	}
1d6316f5 RG	676	}
	677
	678	res = ds1343_sysfs_register(&spi->dev);
	679	if (res)
	680	dev_err(&spi->dev,
	681	"unable to create sysfs entries for rtc ds1343\n");
	682
	683	return 0;
	684	}
	685
	686	static int ds1343_remove(struct spi_device *spi)
	687	{
	688	struct ds1343_priv *priv = spi_get_drvdata(spi);
	689
	690	if (spi->irq) {
	691	mutex_lock(&priv->mutex);
	692	priv->irqen &= ~RTC_AF;
	693	mutex_unlock(&priv->mutex);
	694
caff0cc4 SH	695	dev_pm_clear_wake_irq(&spi->dev);
caff0cc4 SH	696	device_init_wakeup(&spi->dev, false);
1d6316f5 RG	697	devm_free_irq(&spi->dev, spi->irq, priv);
	698	}
	699
	700	spi_set_drvdata(spi, NULL);
	701
	702	ds1343_sysfs_unregister(&spi->dev);
	703
	704	return 0;
	705	}
	706
	707	#ifdef CONFIG_PM_SLEEP
	708
	709	static int ds1343_suspend(struct device *dev)
	710	{
	711	struct spi_device *spi = to_spi_device(dev);
	712
	713	if (spi->irq >= 0 && device_may_wakeup(dev))
	714	enable_irq_wake(spi->irq);
	715
	716	return 0;
	717	}
	718
	719	static int ds1343_resume(struct device *dev)
	720	{
	721	struct spi_device *spi = to_spi_device(dev);
	722
	723	if (spi->irq >= 0 && device_may_wakeup(dev))
	724	disable_irq_wake(spi->irq);
	725
	726	return 0;
	727	}
	728
	729	#endif
	730
	731	static SIMPLE_DEV_PM_OPS(ds1343_pm, ds1343_suspend, ds1343_resume);
	732
	733	static struct spi_driver ds1343_driver = {
	734	.driver = {
	735	.name = "ds1343",
1d6316f5 RG	736	.pm = &ds1343_pm,
	737	},
	738	.probe = ds1343_probe,
	739	.remove = ds1343_remove,
	740	.id_table = ds1343_id,
	741	};
	742
	743	module_spi_driver(ds1343_driver);
	744
	745	MODULE_DESCRIPTION("DS1343 RTC SPI Driver");
571eb883 RG	746	MODULE_AUTHOR("Raghavendra Chandra Ganiga <ravi23ganiga@gmail.com>,"
571eb883 RG	747	"Ankur Srivastava <sankurece@gmail.com>");
1d6316f5	748	MODULE_LICENSE("GPL v2");