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

/*
 * ST M48T59 RTC driver
 *
 * Copyright (c) 2007 Wind River Systems, Inc.
 *
 * Author: Mark Zhan <rongkai.zhan@windriver.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/io.h>
#include <linux/device.h>
#include <linux/platform_device.h>
#include <linux/rtc.h>
#include <linux/rtc/m48t59.h>
#include <linux/bcd.h>
#include <linux/slab.h>

#ifndef NO_IRQ
#define NO_IRQ	(-1)
#endif

#define M48T59_READ(reg) (pdata->read_byte(dev, pdata->offset + reg))
#define M48T59_WRITE(val, reg) \
	(pdata->write_byte(dev, pdata->offset + reg, val))

#define M48T59_SET_BITS(mask, reg)	\
	M48T59_WRITE((M48T59_READ(reg) | (mask)), (reg))
#define M48T59_CLEAR_BITS(mask, reg)	\
	M48T59_WRITE((M48T59_READ(reg) & ~(mask)), (reg))

struct m48t59_private {
	void __iomem *ioaddr;
	int irq;
	struct rtc_device *rtc;
	spinlock_t lock; /* serialize the NVRAM and RTC access */
};

/*
 * This is the generic access method when the chip is memory-mapped
 */
static void
m48t59_mem_writeb(struct device *dev, u32 ofs, u8 val)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct m48t59_private *m48t59 = platform_get_drvdata(pdev);

	writeb(val, m48t59->ioaddr+ofs);
}

static u8
m48t59_mem_readb(struct device *dev, u32 ofs)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct m48t59_private *m48t59 = platform_get_drvdata(pdev);

	return readb(m48t59->ioaddr+ofs);
}

/*
 * NOTE: M48T59 only uses BCD mode
 */
static int m48t59_rtc_read_time(struct device *dev, struct rtc_time *tm)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct m48t59_plat_data *pdata = dev_get_platdata(&pdev->dev);
	struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
	unsigned long flags;
	u8 val;

	spin_lock_irqsave(&m48t59->lock, flags);
	/* Issue the READ command */
	M48T59_SET_BITS(M48T59_CNTL_READ, M48T59_CNTL);

	tm->tm_year	= bcd2bin(M48T59_READ(M48T59_YEAR));
	/* tm_mon is 0-11 */
	tm->tm_mon	= bcd2bin(M48T59_READ(M48T59_MONTH)) - 1;
	tm->tm_mday	= bcd2bin(M48T59_READ(M48T59_MDAY));

	val = M48T59_READ(M48T59_WDAY);
	if ((pdata->type == M48T59RTC_TYPE_M48T59) &&
	    (val & M48T59_WDAY_CEB) && (val & M48T59_WDAY_CB)) {
		dev_dbg(dev, "Century bit is enabled\n");
		tm->tm_year += 100;	/* one century */
	}
#ifdef CONFIG_SPARC
	/* Sun SPARC machines count years since 1968 */
	tm->tm_year += 68;
#endif

	tm->tm_wday	= bcd2bin(val & 0x07);
	tm->tm_hour	= bcd2bin(M48T59_READ(M48T59_HOUR) & 0x3F);
	tm->tm_min	= bcd2bin(M48T59_READ(M48T59_MIN) & 0x7F);
	tm->tm_sec	= bcd2bin(M48T59_READ(M48T59_SEC) & 0x7F);

	/* Clear the READ bit */
	M48T59_CLEAR_BITS(M48T59_CNTL_READ, M48T59_CNTL);
	spin_unlock_irqrestore(&m48t59->lock, flags);

	dev_dbg(dev, "RTC read time %04d-%02d-%02d %02d/%02d/%02d\n",
		tm->tm_year + 1900, tm->tm_mon, tm->tm_mday,
		tm->tm_hour, tm->tm_min, tm->tm_sec);
	return rtc_valid_tm(tm);
}

static int m48t59_rtc_set_time(struct device *dev, struct rtc_time *tm)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct m48t59_plat_data *pdata = dev_get_platdata(&pdev->dev);
	struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
	unsigned long flags;
	u8 val = 0;
	int year = tm->tm_year;

#ifdef CONFIG_SPARC
	/* Sun SPARC machines count years since 1968 */
	year -= 68;
#endif

	dev_dbg(dev, "RTC set time %04d-%02d-%02d %02d/%02d/%02d\n",
		year + 1900, tm->tm_mon, tm->tm_mday,
		tm->tm_hour, tm->tm_min, tm->tm_sec);

	if (year < 0)
		return -EINVAL;

	spin_lock_irqsave(&m48t59->lock, flags);
	/* Issue the WRITE command */
	M48T59_SET_BITS(M48T59_CNTL_WRITE, M48T59_CNTL);

	M48T59_WRITE((bin2bcd(tm->tm_sec) & 0x7F), M48T59_SEC);
	M48T59_WRITE((bin2bcd(tm->tm_min) & 0x7F), M48T59_MIN);
	M48T59_WRITE((bin2bcd(tm->tm_hour) & 0x3F), M48T59_HOUR);
	M48T59_WRITE((bin2bcd(tm->tm_mday) & 0x3F), M48T59_MDAY);
	/* tm_mon is 0-11 */
	M48T59_WRITE((bin2bcd(tm->tm_mon + 1) & 0x1F), M48T59_MONTH);
	M48T59_WRITE(bin2bcd(year % 100), M48T59_YEAR);

	if (pdata->type == M48T59RTC_TYPE_M48T59 && (year / 100))
		val = (M48T59_WDAY_CEB | M48T59_WDAY_CB);
	val |= (bin2bcd(tm->tm_wday) & 0x07);
	M48T59_WRITE(val, M48T59_WDAY);

	/* Clear the WRITE bit */
	M48T59_CLEAR_BITS(M48T59_CNTL_WRITE, M48T59_CNTL);
	spin_unlock_irqrestore(&m48t59->lock, flags);
	return 0;
}

/*
 * Read alarm time and date in RTC
 */
static int m48t59_rtc_readalarm(struct device *dev, struct rtc_wkalrm *alrm)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct m48t59_plat_data *pdata = dev_get_platdata(&pdev->dev);
	struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
	struct rtc_time *tm = &alrm->time;
	unsigned long flags;
	u8 val;

	/* If no irq, we don't support ALARM */
	if (m48t59->irq == NO_IRQ)
		return -EIO;

	spin_lock_irqsave(&m48t59->lock, flags);
	/* Issue the READ command */
	M48T59_SET_BITS(M48T59_CNTL_READ, M48T59_CNTL);

	tm->tm_year = bcd2bin(M48T59_READ(M48T59_YEAR));
#ifdef CONFIG_SPARC
	/* Sun SPARC machines count years since 1968 */
	tm->tm_year += 68;
#endif
	/* tm_mon is 0-11 */
	tm->tm_mon = bcd2bin(M48T59_READ(M48T59_MONTH)) - 1;

	val = M48T59_READ(M48T59_WDAY);
	if ((val & M48T59_WDAY_CEB) && (val & M48T59_WDAY_CB))
		tm->tm_year += 100;	/* one century */

	tm->tm_mday = bcd2bin(M48T59_READ(M48T59_ALARM_DATE));
	tm->tm_hour = bcd2bin(M48T59_READ(M48T59_ALARM_HOUR));
	tm->tm_min = bcd2bin(M48T59_READ(M48T59_ALARM_MIN));
	tm->tm_sec = bcd2bin(M48T59_READ(M48T59_ALARM_SEC));

	/* Clear the READ bit */
	M48T59_CLEAR_BITS(M48T59_CNTL_READ, M48T59_CNTL);
	spin_unlock_irqrestore(&m48t59->lock, flags);

	dev_dbg(dev, "RTC read alarm time %04d-%02d-%02d %02d/%02d/%02d\n",
		tm->tm_year + 1900, tm->tm_mon, tm->tm_mday,
		tm->tm_hour, tm->tm_min, tm->tm_sec);
	return rtc_valid_tm(tm);
}

/*
 * Set alarm time and date in RTC
 */
static int m48t59_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct m48t59_plat_data *pdata = dev_get_platdata(&pdev->dev);
	struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
	struct rtc_time *tm = &alrm->time;
	u8 mday, hour, min, sec;
	unsigned long flags;
	int year = tm->tm_year;

#ifdef CONFIG_SPARC
	/* Sun SPARC machines count years since 1968 */
	year -= 68;
#endif

	/* If no irq, we don't support ALARM */
	if (m48t59->irq == NO_IRQ)
		return -EIO;

	if (year < 0)
		return -EINVAL;

	/*
	 * 0xff means "always match"
	 */
	mday = tm->tm_mday;
	mday = (mday >= 1 && mday <= 31) ? bin2bcd(mday) : 0xff;
	if (mday == 0xff)
		mday = M48T59_READ(M48T59_MDAY);

	hour = tm->tm_hour;
	hour = (hour < 24) ? bin2bcd(hour) : 0x00;

	min = tm->tm_min;
	min = (min < 60) ? bin2bcd(min) : 0x00;

	sec = tm->tm_sec;
	sec = (sec < 60) ? bin2bcd(sec) : 0x00;

	spin_lock_irqsave(&m48t59->lock, flags);
	/* Issue the WRITE command */
	M48T59_SET_BITS(M48T59_CNTL_WRITE, M48T59_CNTL);

	M48T59_WRITE(mday, M48T59_ALARM_DATE);
	M48T59_WRITE(hour, M48T59_ALARM_HOUR);
	M48T59_WRITE(min, M48T59_ALARM_MIN);
	M48T59_WRITE(sec, M48T59_ALARM_SEC);

	/* Clear the WRITE bit */
	M48T59_CLEAR_BITS(M48T59_CNTL_WRITE, M48T59_CNTL);
	spin_unlock_irqrestore(&m48t59->lock, flags);

	dev_dbg(dev, "RTC set alarm time %04d-%02d-%02d %02d/%02d/%02d\n",
		year + 1900, tm->tm_mon, tm->tm_mday,
		tm->tm_hour, tm->tm_min, tm->tm_sec);
	return 0;
}

/*
 * Handle commands from user-space
 */
static int m48t59_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct m48t59_plat_data *pdata = dev_get_platdata(&pdev->dev);
	struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
	unsigned long flags;

	spin_lock_irqsave(&m48t59->lock, flags);
	if (enabled)
		M48T59_WRITE(M48T59_INTR_AFE, M48T59_INTR);
	else
		M48T59_WRITE(0x00, M48T59_INTR);
	spin_unlock_irqrestore(&m48t59->lock, flags);

	return 0;
}

static int m48t59_rtc_proc(struct device *dev, struct seq_file *seq)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct m48t59_plat_data *pdata = dev_get_platdata(&pdev->dev);
	struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
	unsigned long flags;
	u8 val;

	spin_lock_irqsave(&m48t59->lock, flags);
	val = M48T59_READ(M48T59_FLAGS);
	spin_unlock_irqrestore(&m48t59->lock, flags);

	seq_printf(seq, "battery\t\t: %s\n",
		 (val & M48T59_FLAGS_BF) ? "low" : "normal");
	return 0;
}

/*
 * IRQ handler for the RTC
 */
static irqreturn_t m48t59_rtc_interrupt(int irq, void *dev_id)
{
	struct device *dev = (struct device *)dev_id;
	struct platform_device *pdev = to_platform_device(dev);
	struct m48t59_plat_data *pdata = dev_get_platdata(&pdev->dev);
	struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
	u8 event;

	spin_lock(&m48t59->lock);
	event = M48T59_READ(M48T59_FLAGS);
	spin_unlock(&m48t59->lock);

	if (event & M48T59_FLAGS_AF) {
		rtc_update_irq(m48t59->rtc, 1, (RTC_AF | RTC_IRQF));
		return IRQ_HANDLED;
	}

	return IRQ_NONE;
}

static const struct rtc_class_ops m48t59_rtc_ops = {
	.read_time	= m48t59_rtc_read_time,
	.set_time	= m48t59_rtc_set_time,
	.read_alarm	= m48t59_rtc_readalarm,
	.set_alarm	= m48t59_rtc_setalarm,
	.proc		= m48t59_rtc_proc,
	.alarm_irq_enable = m48t59_rtc_alarm_irq_enable,
};

static const struct rtc_class_ops m48t02_rtc_ops = {
	.read_time	= m48t59_rtc_read_time,
	.set_time	= m48t59_rtc_set_time,
};

static ssize_t m48t59_nvram_read(struct file *filp, struct kobject *kobj,
				struct bin_attribute *bin_attr,
				char *buf, loff_t pos, size_t size)
{
	struct device *dev = container_of(kobj, struct device, kobj);
	struct platform_device *pdev = to_platform_device(dev);
	struct m48t59_plat_data *pdata = dev_get_platdata(&pdev->dev);
	struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
	ssize_t cnt = 0;
	unsigned long flags;

	spin_lock_irqsave(&m48t59->lock, flags);

	for (; cnt < size; cnt++)
		*buf++ = M48T59_READ(cnt);

	spin_unlock_irqrestore(&m48t59->lock, flags);

	return cnt;
}

static ssize_t m48t59_nvram_write(struct file *filp, struct kobject *kobj,
				struct bin_attribute *bin_attr,
				char *buf, loff_t pos, size_t size)
{
	struct device *dev = container_of(kobj, struct device, kobj);
	struct platform_device *pdev = to_platform_device(dev);
	struct m48t59_plat_data *pdata = dev_get_platdata(&pdev->dev);
	struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
	ssize_t cnt = 0;
	unsigned long flags;

	spin_lock_irqsave(&m48t59->lock, flags);

	for (; cnt < size; cnt++)
		M48T59_WRITE(*buf++, cnt);

	spin_unlock_irqrestore(&m48t59->lock, flags);

	return cnt;
}

static struct bin_attribute m48t59_nvram_attr = {
	.attr = {
		.name = "nvram",
		.mode = S_IRUGO | S_IWUSR,
	},
	.read = m48t59_nvram_read,
	.write = m48t59_nvram_write,
};

static int m48t59_rtc_probe(struct platform_device *pdev)
{
	struct m48t59_plat_data *pdata = dev_get_platdata(&pdev->dev);
	struct m48t59_private *m48t59 = NULL;
	struct resource *res;
	int ret = -ENOMEM;
	char *name;
	const struct rtc_class_ops *ops;

	/* This chip could be memory-mapped or I/O-mapped */
	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (!res) {
		res = platform_get_resource(pdev, IORESOURCE_IO, 0);
		if (!res)
			return -EINVAL;
	}

	if (res->flags & IORESOURCE_IO) {
		/* If we are I/O-mapped, the platform should provide
		 * the operations accessing chip registers.
		 */
		if (!pdata || !pdata->write_byte || !pdata->read_byte)
			return -EINVAL;
	} else if (res->flags & IORESOURCE_MEM) {
		/* we are memory-mapped */
		if (!pdata) {
			pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata),
						GFP_KERNEL);
			if (!pdata)
				return -ENOMEM;
			/* Ensure we only kmalloc platform data once */
			pdev->dev.platform_data = pdata;
		}
		if (!pdata->type)
			pdata->type = M48T59RTC_TYPE_M48T59;

		/* Try to use the generic memory read/write ops */
		if (!pdata->write_byte)
			pdata->write_byte = m48t59_mem_writeb;
		if (!pdata->read_byte)
			pdata->read_byte = m48t59_mem_readb;
	}

	m48t59 = devm_kzalloc(&pdev->dev, sizeof(*m48t59), GFP_KERNEL);
	if (!m48t59)
		return -ENOMEM;

	m48t59->ioaddr = pdata->ioaddr;

	if (!m48t59->ioaddr) {
		/* ioaddr not mapped externally */
		m48t59->ioaddr = devm_ioremap(&pdev->dev, res->start,
						resource_size(res));
		if (!m48t59->ioaddr)
			return ret;
	}

	/* Try to get irq number. We also can work in
	 * the mode without IRQ.
	 */
	m48t59->irq = platform_get_irq(pdev, 0);
	if (m48t59->irq <= 0)
		m48t59->irq = NO_IRQ;

	if (m48t59->irq != NO_IRQ) {
		ret = devm_request_irq(&pdev->dev, m48t59->irq,
				m48t59_rtc_interrupt, IRQF_SHARED,
				"rtc-m48t59", &pdev->dev);
		if (ret)
			return ret;
	}
	switch (pdata->type) {
	case M48T59RTC_TYPE_M48T59:
		name = "m48t59";
		ops = &m48t59_rtc_ops;
		pdata->offset = 0x1ff0;
		break;
	case M48T59RTC_TYPE_M48T02:
		name = "m48t02";
		ops = &m48t02_rtc_ops;
		pdata->offset = 0x7f0;
		break;
	case M48T59RTC_TYPE_M48T08:
		name = "m48t08";
		ops = &m48t02_rtc_ops;
		pdata->offset = 0x1ff0;
		break;
	default:
		dev_err(&pdev->dev, "Unknown RTC type\n");
		return -ENODEV;
	}

	spin_lock_init(&m48t59->lock);
	platform_set_drvdata(pdev, m48t59);

	m48t59->rtc = devm_rtc_device_register(&pdev->dev, name, ops,
						THIS_MODULE);
	if (IS_ERR(m48t59->rtc))
		return PTR_ERR(m48t59->rtc);

	m48t59_nvram_attr.size = pdata->offset;

	ret = sysfs_create_bin_file(&pdev->dev.kobj, &m48t59_nvram_attr);
	if (ret)
		return ret;

	return 0;
}

static int m48t59_rtc_remove(struct platform_device *pdev)
{
	sysfs_remove_bin_file(&pdev->dev.kobj, &m48t59_nvram_attr);
	return 0;
}

/* work with hotplug and coldplug */
MODULE_ALIAS("platform:rtc-m48t59");

static struct platform_driver m48t59_rtc_driver = {
	.driver		= {
		.name	= "rtc-m48t59",
	},
	.probe		= m48t59_rtc_probe,
	.remove		= m48t59_rtc_remove,
};

module_platform_driver(m48t59_rtc_driver);

MODULE_AUTHOR("Mark Zhan <rongkai.zhan@windriver.com>");
MODULE_DESCRIPTION("M48T59/M48T02/M48T08 RTC driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
2e774c7c MZ	1	/*
	2	* ST M48T59 RTC driver
	3	*
	4	* Copyright (c) 2007 Wind River Systems, Inc.
	5	*
	6	* Author: Mark Zhan <rongkai.zhan@windriver.com>
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License version 2 as
	10	* published by the Free Software Foundation.
	11	*/
	12
	13	#include <linux/kernel.h>
	14	#include <linux/module.h>
	15	#include <linux/init.h>
	16	#include <linux/io.h>
	17	#include <linux/device.h>
	18	#include <linux/platform_device.h>
	19	#include <linux/rtc.h>
	20	#include <linux/rtc/m48t59.h>
	21	#include <linux/bcd.h>
5a0e3ad6	22	#include <linux/slab.h>
2e774c7c MZ	23
	24	#ifndef NO_IRQ
	25	#define NO_IRQ (-1)
	26	#endif
	27
94fe7424 KH	28	#define M48T59_READ(reg) (pdata->read_byte(dev, pdata->offset + reg))
	29	#define M48T59_WRITE(val, reg) \
	30	(pdata->write_byte(dev, pdata->offset + reg, val))
2e774c7c MZ	31
	32	#define M48T59_SET_BITS(mask, reg) \
	33	M48T59_WRITE((M48T59_READ(reg) \| (mask)), (reg))
	34	#define M48T59_CLEAR_BITS(mask, reg) \
	35	M48T59_WRITE((M48T59_READ(reg) & ~(mask)), (reg))
	36
	37	struct m48t59_private {
	38	void __iomem *ioaddr;
0439208a	39	int irq;
2e774c7c MZ	40	struct rtc_device *rtc;
	41	spinlock_t lock; /* serialize the NVRAM and RTC access */
	42	};
	43
	44	/*
	45	* This is the generic access method when the chip is memory-mapped
	46	*/
	47	static void
	48	m48t59_mem_writeb(struct device *dev, u32 ofs, u8 val)
	49	{
	50	struct platform_device *pdev = to_platform_device(dev);
	51	struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
	52
	53	writeb(val, m48t59->ioaddr+ofs);
	54	}
	55
	56	static u8
	57	m48t59_mem_readb(struct device *dev, u32 ofs)
	58	{
	59	struct platform_device *pdev = to_platform_device(dev);
	60	struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
	61
	62	return readb(m48t59->ioaddr+ofs);
	63	}
	64
	65	/*
	66	* NOTE: M48T59 only uses BCD mode
	67	*/
	68	static int m48t59_rtc_read_time(struct device dev, struct rtc_time tm)
	69	{
	70	struct platform_device *pdev = to_platform_device(dev);
8136032b	71	struct m48t59_plat_data *pdata = dev_get_platdata(&pdev->dev);
2e774c7c MZ	72	struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
	73	unsigned long flags;
	74	u8 val;
	75
	76	spin_lock_irqsave(&m48t59->lock, flags);
	77	/* Issue the READ command */
	78	M48T59_SET_BITS(M48T59_CNTL_READ, M48T59_CNTL);
	79
fe20ba70	80	tm->tm_year = bcd2bin(M48T59_READ(M48T59_YEAR));
2e774c7c	81	/* tm_mon is 0-11 */
fe20ba70 AB	82	tm->tm_mon = bcd2bin(M48T59_READ(M48T59_MONTH)) - 1;
fe20ba70 AB	83	tm->tm_mday = bcd2bin(M48T59_READ(M48T59_MDAY));
2e774c7c MZ	84
2e774c7c MZ	85	val = M48T59_READ(M48T59_WDAY);
833be4e1 RR	86	if ((pdata->type == M48T59RTC_TYPE_M48T59) &&
833be4e1 RR	87	(val & M48T59_WDAY_CEB) && (val & M48T59_WDAY_CB)) {
2e774c7c MZ	88	dev_dbg(dev, "Century bit is enabled\n");
	89	tm->tm_year += 100; /* one century */
	90	}
12a9ee3c KH	91	#ifdef CONFIG_SPARC
	92	/* Sun SPARC machines count years since 1968 */
	93	tm->tm_year += 68;
	94	#endif
2e774c7c	95
fe20ba70 AB	96	tm->tm_wday = bcd2bin(val & 0x07);
	97	tm->tm_hour = bcd2bin(M48T59_READ(M48T59_HOUR) & 0x3F);
	98	tm->tm_min = bcd2bin(M48T59_READ(M48T59_MIN) & 0x7F);
	99	tm->tm_sec = bcd2bin(M48T59_READ(M48T59_SEC) & 0x7F);
2e774c7c MZ	100
	101	/* Clear the READ bit */
	102	M48T59_CLEAR_BITS(M48T59_CNTL_READ, M48T59_CNTL);
	103	spin_unlock_irqrestore(&m48t59->lock, flags);
	104
	105	dev_dbg(dev, "RTC read time %04d-%02d-%02d %02d/%02d/%02d\n",
	106	tm->tm_year + 1900, tm->tm_mon, tm->tm_mday,
	107	tm->tm_hour, tm->tm_min, tm->tm_sec);
caf1e106	108	return rtc_valid_tm(tm);
2e774c7c MZ	109	}
	110
	111	static int m48t59_rtc_set_time(struct device dev, struct rtc_time tm)
	112	{
	113	struct platform_device *pdev = to_platform_device(dev);
8136032b	114	struct m48t59_plat_data *pdata = dev_get_platdata(&pdev->dev);
2e774c7c MZ	115	struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
	116	unsigned long flags;
	117	u8 val = 0;
12a9ee3c KH	118	int year = tm->tm_year;
	119
	120	#ifdef CONFIG_SPARC
	121	/* Sun SPARC machines count years since 1968 */
	122	year -= 68;
	123	#endif
2e774c7c MZ	124
2e774c7c MZ	125	dev_dbg(dev, "RTC set time %04d-%02d-%02d %02d/%02d/%02d\n",
12a9ee3c	126	year + 1900, tm->tm_mon, tm->tm_mday,
2e774c7c MZ	127	tm->tm_hour, tm->tm_min, tm->tm_sec);
2e774c7c MZ	128
12a9ee3c KH	129	if (year < 0)
	130	return -EINVAL;
	131
2e774c7c MZ	132	spin_lock_irqsave(&m48t59->lock, flags);
	133	/* Issue the WRITE command */
	134	M48T59_SET_BITS(M48T59_CNTL_WRITE, M48T59_CNTL);
	135
fe20ba70 AB	136	M48T59_WRITE((bin2bcd(tm->tm_sec) & 0x7F), M48T59_SEC);
	137	M48T59_WRITE((bin2bcd(tm->tm_min) & 0x7F), M48T59_MIN);
	138	M48T59_WRITE((bin2bcd(tm->tm_hour) & 0x3F), M48T59_HOUR);
	139	M48T59_WRITE((bin2bcd(tm->tm_mday) & 0x3F), M48T59_MDAY);
2e774c7c	140	/* tm_mon is 0-11 */
fe20ba70	141	M48T59_WRITE((bin2bcd(tm->tm_mon + 1) & 0x1F), M48T59_MONTH);
12a9ee3c	142	M48T59_WRITE(bin2bcd(year % 100), M48T59_YEAR);
2e774c7c	143
12a9ee3c	144	if (pdata->type == M48T59RTC_TYPE_M48T59 && (year / 100))
2e774c7c	145	val = (M48T59_WDAY_CEB \| M48T59_WDAY_CB);
fe20ba70	146	val \|= (bin2bcd(tm->tm_wday) & 0x07);
2e774c7c MZ	147	M48T59_WRITE(val, M48T59_WDAY);
	148
	149	/* Clear the WRITE bit */
	150	M48T59_CLEAR_BITS(M48T59_CNTL_WRITE, M48T59_CNTL);
	151	spin_unlock_irqrestore(&m48t59->lock, flags);
	152	return 0;
	153	}
	154
	155	/*
	156	* Read alarm time and date in RTC
	157	*/
	158	static int m48t59_rtc_readalarm(struct device dev, struct rtc_wkalrm alrm)
	159	{
	160	struct platform_device *pdev = to_platform_device(dev);
8136032b	161	struct m48t59_plat_data *pdata = dev_get_platdata(&pdev->dev);
2e774c7c MZ	162	struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
	163	struct rtc_time *tm = &alrm->time;
	164	unsigned long flags;
	165	u8 val;
	166
	167	/* If no irq, we don't support ALARM */
	168	if (m48t59->irq == NO_IRQ)
	169	return -EIO;
	170
	171	spin_lock_irqsave(&m48t59->lock, flags);
	172	/* Issue the READ command */
	173	M48T59_SET_BITS(M48T59_CNTL_READ, M48T59_CNTL);
	174
fe20ba70	175	tm->tm_year = bcd2bin(M48T59_READ(M48T59_YEAR));
12a9ee3c KH	176	#ifdef CONFIG_SPARC
	177	/* Sun SPARC machines count years since 1968 */
	178	tm->tm_year += 68;
	179	#endif
2e774c7c	180	/* tm_mon is 0-11 */
fe20ba70	181	tm->tm_mon = bcd2bin(M48T59_READ(M48T59_MONTH)) - 1;
2e774c7c MZ	182
	183	val = M48T59_READ(M48T59_WDAY);
	184	if ((val & M48T59_WDAY_CEB) && (val & M48T59_WDAY_CB))
	185	tm->tm_year += 100; /* one century */
	186
fe20ba70 AB	187	tm->tm_mday = bcd2bin(M48T59_READ(M48T59_ALARM_DATE));
	188	tm->tm_hour = bcd2bin(M48T59_READ(M48T59_ALARM_HOUR));
	189	tm->tm_min = bcd2bin(M48T59_READ(M48T59_ALARM_MIN));
	190	tm->tm_sec = bcd2bin(M48T59_READ(M48T59_ALARM_SEC));
2e774c7c MZ	191
	192	/* Clear the READ bit */
	193	M48T59_CLEAR_BITS(M48T59_CNTL_READ, M48T59_CNTL);
	194	spin_unlock_irqrestore(&m48t59->lock, flags);
	195
	196	dev_dbg(dev, "RTC read alarm time %04d-%02d-%02d %02d/%02d/%02d\n",
	197	tm->tm_year + 1900, tm->tm_mon, tm->tm_mday,
	198	tm->tm_hour, tm->tm_min, tm->tm_sec);
caf1e106	199	return rtc_valid_tm(tm);
2e774c7c MZ	200	}
	201
	202	/*
	203	* Set alarm time and date in RTC
	204	*/
	205	static int m48t59_rtc_setalarm(struct device dev, struct rtc_wkalrm alrm)
	206	{
	207	struct platform_device *pdev = to_platform_device(dev);
8136032b	208	struct m48t59_plat_data *pdata = dev_get_platdata(&pdev->dev);
2e774c7c MZ	209	struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
	210	struct rtc_time *tm = &alrm->time;
	211	u8 mday, hour, min, sec;
	212	unsigned long flags;
12a9ee3c KH	213	int year = tm->tm_year;
	214
	215	#ifdef CONFIG_SPARC
	216	/* Sun SPARC machines count years since 1968 */
	217	year -= 68;
	218	#endif
2e774c7c MZ	219
	220	/* If no irq, we don't support ALARM */
	221	if (m48t59->irq == NO_IRQ)
	222	return -EIO;
	223
12a9ee3c KH	224	if (year < 0)
	225	return -EINVAL;
	226
2e774c7c MZ	227	/*
	228	* 0xff means "always match"
	229	*/
	230	mday = tm->tm_mday;
fe20ba70	231	mday = (mday >= 1 && mday <= 31) ? bin2bcd(mday) : 0xff;
2e774c7c MZ	232	if (mday == 0xff)
	233	mday = M48T59_READ(M48T59_MDAY);
	234
	235	hour = tm->tm_hour;
fe20ba70	236	hour = (hour < 24) ? bin2bcd(hour) : 0x00;
2e774c7c MZ	237
2e774c7c MZ	238	min = tm->tm_min;
fe20ba70	239	min = (min < 60) ? bin2bcd(min) : 0x00;
2e774c7c MZ	240
2e774c7c MZ	241	sec = tm->tm_sec;
fe20ba70	242	sec = (sec < 60) ? bin2bcd(sec) : 0x00;
2e774c7c MZ	243
	244	spin_lock_irqsave(&m48t59->lock, flags);
	245	/* Issue the WRITE command */
	246	M48T59_SET_BITS(M48T59_CNTL_WRITE, M48T59_CNTL);
	247
	248	M48T59_WRITE(mday, M48T59_ALARM_DATE);
	249	M48T59_WRITE(hour, M48T59_ALARM_HOUR);
	250	M48T59_WRITE(min, M48T59_ALARM_MIN);
	251	M48T59_WRITE(sec, M48T59_ALARM_SEC);
	252
	253	/* Clear the WRITE bit */
	254	M48T59_CLEAR_BITS(M48T59_CNTL_WRITE, M48T59_CNTL);
	255	spin_unlock_irqrestore(&m48t59->lock, flags);
	256
	257	dev_dbg(dev, "RTC set alarm time %04d-%02d-%02d %02d/%02d/%02d\n",
12a9ee3c	258	year + 1900, tm->tm_mon, tm->tm_mday,
2e774c7c MZ	259	tm->tm_hour, tm->tm_min, tm->tm_sec);
	260	return 0;
	261	}
	262
	263	/*
	264	* Handle commands from user-space
	265	*/
16380c15	266	static int m48t59_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
2e774c7c MZ	267	{
2e774c7c MZ	268	struct platform_device *pdev = to_platform_device(dev);
8136032b	269	struct m48t59_plat_data *pdata = dev_get_platdata(&pdev->dev);
2e774c7c MZ	270	struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
2e774c7c MZ	271	unsigned long flags;
2e774c7c MZ	272
2e774c7c MZ	273	spin_lock_irqsave(&m48t59->lock, flags);
16380c15	274	if (enabled)
2e774c7c	275	M48T59_WRITE(M48T59_INTR_AFE, M48T59_INTR);
16380c15 JS	276	else
16380c15 JS	277	M48T59_WRITE(0x00, M48T59_INTR);
2e774c7c MZ	278	spin_unlock_irqrestore(&m48t59->lock, flags);
2e774c7c MZ	279
16380c15	280	return 0;
2e774c7c MZ	281	}
	282
	283	static int m48t59_rtc_proc(struct device dev, struct seq_file seq)
	284	{
	285	struct platform_device *pdev = to_platform_device(dev);
8136032b	286	struct m48t59_plat_data *pdata = dev_get_platdata(&pdev->dev);
2e774c7c MZ	287	struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
	288	unsigned long flags;
	289	u8 val;
	290
	291	spin_lock_irqsave(&m48t59->lock, flags);
	292	val = M48T59_READ(M48T59_FLAGS);
	293	spin_unlock_irqrestore(&m48t59->lock, flags);
	294
	295	seq_printf(seq, "battery\t\t: %s\n",
	296	(val & M48T59_FLAGS_BF) ? "low" : "normal");
	297	return 0;
	298	}
	299
	300	/*
	301	* IRQ handler for the RTC
	302	*/
	303	static irqreturn_t m48t59_rtc_interrupt(int irq, void *dev_id)
	304	{
	305	struct device dev = (struct device )dev_id;
	306	struct platform_device *pdev = to_platform_device(dev);
8136032b	307	struct m48t59_plat_data *pdata = dev_get_platdata(&pdev->dev);
2e774c7c MZ	308	struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
	309	u8 event;
	310
	311	spin_lock(&m48t59->lock);
	312	event = M48T59_READ(M48T59_FLAGS);
	313	spin_unlock(&m48t59->lock);
	314
	315	if (event & M48T59_FLAGS_AF) {
	316	rtc_update_irq(m48t59->rtc, 1, (RTC_AF \| RTC_IRQF));
	317	return IRQ_HANDLED;
	318	}
	319
	320	return IRQ_NONE;
	321	}
	322
	323	static const struct rtc_class_ops m48t59_rtc_ops = {
2e774c7c MZ	324	.read_time = m48t59_rtc_read_time,
	325	.set_time = m48t59_rtc_set_time,
	326	.read_alarm = m48t59_rtc_readalarm,
	327	.set_alarm = m48t59_rtc_setalarm,
	328	.proc = m48t59_rtc_proc,
16380c15	329	.alarm_irq_enable = m48t59_rtc_alarm_irq_enable,
2e774c7c MZ	330	};
2e774c7c MZ	331
94fe7424 KH	332	static const struct rtc_class_ops m48t02_rtc_ops = {
	333	.read_time = m48t59_rtc_read_time,
	334	.set_time = m48t59_rtc_set_time,
	335	};
	336
2c3c8bea	337	static ssize_t m48t59_nvram_read(struct file filp, struct kobject kobj,
2e774c7c MZ	338	struct bin_attribute *bin_attr,
	339	char *buf, loff_t pos, size_t size)
	340	{
	341	struct device *dev = container_of(kobj, struct device, kobj);
	342	struct platform_device *pdev = to_platform_device(dev);
8136032b	343	struct m48t59_plat_data *pdata = dev_get_platdata(&pdev->dev);
2e774c7c MZ	344	struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
	345	ssize_t cnt = 0;
	346	unsigned long flags;
	347
99be3e37 VZ	348	spin_lock_irqsave(&m48t59->lock, flags);
	349
	350	for (; cnt < size; cnt++)
2e774c7c	351	*buf++ = M48T59_READ(cnt);
99be3e37 VZ	352
99be3e37 VZ	353	spin_unlock_irqrestore(&m48t59->lock, flags);
2e774c7c MZ	354
	355	return cnt;
	356	}
	357
2c3c8bea	358	static ssize_t m48t59_nvram_write(struct file filp, struct kobject kobj,
2e774c7c MZ	359	struct bin_attribute *bin_attr,
	360	char *buf, loff_t pos, size_t size)
	361	{
	362	struct device *dev = container_of(kobj, struct device, kobj);
	363	struct platform_device *pdev = to_platform_device(dev);
8136032b	364	struct m48t59_plat_data *pdata = dev_get_platdata(&pdev->dev);
2e774c7c MZ	365	struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
	366	ssize_t cnt = 0;
	367	unsigned long flags;
	368
99be3e37 VZ	369	spin_lock_irqsave(&m48t59->lock, flags);
	370
	371	for (; cnt < size; cnt++)
2e774c7c	372	M48T59_WRITE(*buf++, cnt);
99be3e37 VZ	373
99be3e37 VZ	374	spin_unlock_irqrestore(&m48t59->lock, flags);
2e774c7c MZ	375
	376	return cnt;
	377	}
	378
	379	static struct bin_attribute m48t59_nvram_attr = {
	380	.attr = {
	381	.name = "nvram",
a4b1d50e	382	.mode = S_IRUGO \| S_IWUSR,
2e774c7c MZ	383	},
	384	.read = m48t59_nvram_read,
	385	.write = m48t59_nvram_write,
	386	};
	387
5a167f45	388	static int m48t59_rtc_probe(struct platform_device *pdev)
2e774c7c	389	{
8136032b	390	struct m48t59_plat_data *pdata = dev_get_platdata(&pdev->dev);
2e774c7c MZ	391	struct m48t59_private *m48t59 = NULL;
	392	struct resource *res;
	393	int ret = -ENOMEM;
94fe7424 KH	394	char *name;
94fe7424 KH	395	const struct rtc_class_ops *ops;
2e774c7c MZ	396
	397	/* This chip could be memory-mapped or I/O-mapped */
	398	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	399	if (!res) {
	400	res = platform_get_resource(pdev, IORESOURCE_IO, 0);
	401	if (!res)
	402	return -EINVAL;
	403	}
	404
	405	if (res->flags & IORESOURCE_IO) {
	406	/* If we are I/O-mapped, the platform should provide
	407	* the operations accessing chip registers.
	408	*/
	409	if (!pdata \|\| !pdata->write_byte \|\| !pdata->read_byte)
	410	return -EINVAL;
	411	} else if (res->flags & IORESOURCE_MEM) {
	412	/* we are memory-mapped */
	413	if (!pdata) {
19b8d887 JH	414	pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata),
19b8d887 JH	415	GFP_KERNEL);
2e774c7c MZ	416	if (!pdata)
	417	return -ENOMEM;
	418	/* Ensure we only kmalloc platform data once */
	419	pdev->dev.platform_data = pdata;
	420	}
94fe7424 KH	421	if (!pdata->type)
94fe7424 KH	422	pdata->type = M48T59RTC_TYPE_M48T59;
2e774c7c MZ	423
	424	/* Try to use the generic memory read/write ops */
	425	if (!pdata->write_byte)
	426	pdata->write_byte = m48t59_mem_writeb;
	427	if (!pdata->read_byte)
	428	pdata->read_byte = m48t59_mem_readb;
	429	}
	430
19b8d887	431	m48t59 = devm_kzalloc(&pdev->dev, sizeof(*m48t59), GFP_KERNEL);
2e774c7c MZ	432	if (!m48t59)
	433	return -ENOMEM;
	434
64151ad5 KH	435	m48t59->ioaddr = pdata->ioaddr;
	436
	437	if (!m48t59->ioaddr) {
	438	/* ioaddr not mapped externally */
19b8d887 JH	439	m48t59->ioaddr = devm_ioremap(&pdev->dev, res->start,
19b8d887 JH	440	resource_size(res));
64151ad5	441	if (!m48t59->ioaddr)
19b8d887	442	return ret;
64151ad5	443	}
2e774c7c MZ	444
	445	/* Try to get irq number. We also can work in
	446	* the mode without IRQ.
	447	*/
	448	m48t59->irq = platform_get_irq(pdev, 0);
2fac6674	449	if (m48t59->irq <= 0)
2e774c7c MZ	450	m48t59->irq = NO_IRQ;
	451
	452	if (m48t59->irq != NO_IRQ) {
19b8d887 JH	453	ret = devm_request_irq(&pdev->dev, m48t59->irq,
	454	m48t59_rtc_interrupt, IRQF_SHARED,
	455	"rtc-m48t59", &pdev->dev);
2e774c7c	456	if (ret)
19b8d887	457	return ret;
2e774c7c	458	}
94fe7424 KH	459	switch (pdata->type) {
	460	case M48T59RTC_TYPE_M48T59:
	461	name = "m48t59";
	462	ops = &m48t59_rtc_ops;
	463	pdata->offset = 0x1ff0;
	464	break;
	465	case M48T59RTC_TYPE_M48T02:
	466	name = "m48t02";
	467	ops = &m48t02_rtc_ops;
	468	pdata->offset = 0x7f0;
	469	break;
	470	case M48T59RTC_TYPE_M48T08:
	471	name = "m48t08";
	472	ops = &m48t02_rtc_ops;
	473	pdata->offset = 0x1ff0;
	474	break;
	475	default:
	476	dev_err(&pdev->dev, "Unknown RTC type\n");
19b8d887	477	return -ENODEV;
94fe7424	478	}
2e774c7c	479
b74d2caa AZ	480	spin_lock_init(&m48t59->lock);
	481	platform_set_drvdata(pdev, m48t59);
	482
19b8d887 JH	483	m48t59->rtc = devm_rtc_device_register(&pdev->dev, name, ops,
	484	THIS_MODULE);
	485	if (IS_ERR(m48t59->rtc))
	486	return PTR_ERR(m48t59->rtc);
2e774c7c	487
94fe7424 KH	488	m48t59_nvram_attr.size = pdata->offset;
94fe7424 KH	489
2e774c7c	490	ret = sysfs_create_bin_file(&pdev->dev.kobj, &m48t59_nvram_attr);
19b8d887 JH	491	if (ret)
19b8d887 JH	492	return ret;
2e774c7c	493
2e774c7c	494	return 0;
2e774c7c MZ	495	}
2e774c7c MZ	496
5a167f45	497	static int m48t59_rtc_remove(struct platform_device *pdev)
2e774c7c	498	{
2e774c7c	499	sysfs_remove_bin_file(&pdev->dev.kobj, &m48t59_nvram_attr);
2e774c7c MZ	500	return 0;
	501	}
	502
ad28a07b KS	503	/* work with hotplug and coldplug */
	504	MODULE_ALIAS("platform:rtc-m48t59");
	505
12730926	506	static struct platform_driver m48t59_rtc_driver = {
2e774c7c MZ	507	.driver = {
2e774c7c MZ	508	.name = "rtc-m48t59",
2e774c7c MZ	509	},
2e774c7c MZ	510	.probe = m48t59_rtc_probe,
5a167f45	511	.remove = m48t59_rtc_remove,
2e774c7c MZ	512	};
2e774c7c MZ	513
0c4eae66	514	module_platform_driver(m48t59_rtc_driver);
2e774c7c MZ	515
2e774c7c MZ	516	MODULE_AUTHOR("Mark Zhan <rongkai.zhan@windriver.com>");
94fe7424	517	MODULE_DESCRIPTION("M48T59/M48T02/M48T08 RTC driver");
2e774c7c	518	MODULE_LICENSE("GPL");