[GitHub/mt8127/android_kernel_alcatel_ttab.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 = pdev->dev.platform_data;
	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 0;
}

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 = pdev->dev.platform_data;
	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 = pdev->dev.platform_data;
	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 0;
}

/*
 * 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 = pdev->dev.platform_data;
	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_ioctl(struct device *dev, unsigned int cmd,
			unsigned long arg)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct m48t59_plat_data *pdata = pdev->dev.platform_data;
	struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
	unsigned long flags;
	int ret = 0;

	spin_lock_irqsave(&m48t59->lock, flags);
	switch (cmd) {
	case RTC_AIE_OFF:	/* alarm interrupt off */
		M48T59_WRITE(0x00, M48T59_INTR);
		break;
	case RTC_AIE_ON:	/* alarm interrupt on */
		M48T59_WRITE(M48T59_INTR_AFE, M48T59_INTR);
		break;
	default:
		ret = -ENOIOCTLCMD;
		break;
	}
	spin_unlock_irqrestore(&m48t59->lock, flags);

	return ret;
}

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 = pdev->dev.platform_data;
	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 = pdev->dev.platform_data;
	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 = {
	.ioctl		= m48t59_rtc_ioctl,
	.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,
};

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 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 = pdev->dev.platform_data;
	struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
	ssize_t cnt = 0;
	unsigned long flags;

	for (; size > 0 && pos < pdata->offset; cnt++, size--) {
		spin_lock_irqsave(&m48t59->lock, flags);
		*buf++ = M48T59_READ(cnt);
		spin_unlock_irqrestore(&m48t59->lock, flags);
	}

	return cnt;
}

static ssize_t m48t59_nvram_write(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 = pdev->dev.platform_data;
	struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
	ssize_t cnt = 0;
	unsigned long flags;

	for (; size > 0 && pos < pdata->offset; cnt++, size--) {
		spin_lock_irqsave(&m48t59->lock, flags);
		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 __devinit m48t59_rtc_probe(struct platform_device *pdev)
{
	struct m48t59_plat_data *pdata = pdev->dev.platform_data;
	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 = kzalloc(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 = kzalloc(sizeof(*m48t59), GFP_KERNEL);
	if (!m48t59)
		return -ENOMEM;

	m48t59->ioaddr = pdata->ioaddr;

	if (!m48t59->ioaddr) {
		/* ioaddr not mapped externally */
		m48t59->ioaddr = ioremap(res->start, res->end - res->start + 1);
		if (!m48t59->ioaddr)
			goto out;
	}

	/* 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 = request_irq(m48t59->irq, m48t59_rtc_interrupt,
			IRQF_SHARED, "rtc-m48t59", &pdev->dev);
		if (ret)
			goto out;
	}
	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");
		ret = -ENODEV;
		goto out;
	}

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

	m48t59->rtc = rtc_device_register(name, &pdev->dev, ops, THIS_MODULE);
	if (IS_ERR(m48t59->rtc)) {
		ret = PTR_ERR(m48t59->rtc);
		goto out;
	}

	m48t59_nvram_attr.size = pdata->offset;

	ret = sysfs_create_bin_file(&pdev->dev.kobj, &m48t59_nvram_attr);
	if (ret) {
		rtc_device_unregister(m48t59->rtc);
		goto out;
	}

	return 0;

out:
	if (m48t59->irq != NO_IRQ)
		free_irq(m48t59->irq, &pdev->dev);
	if (m48t59->ioaddr)
		iounmap(m48t59->ioaddr);
	if (m48t59)
		kfree(m48t59);
	return ret;
}

static int __devexit m48t59_rtc_remove(struct platform_device *pdev)
{
	struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
	struct m48t59_plat_data *pdata = pdev->dev.platform_data;

	sysfs_remove_bin_file(&pdev->dev.kobj, &m48t59_nvram_attr);
	if (!IS_ERR(m48t59->rtc))
		rtc_device_unregister(m48t59->rtc);
	if (m48t59->ioaddr && !pdata->ioaddr)
		iounmap(m48t59->ioaddr);
	if (m48t59->irq != NO_IRQ)
		free_irq(m48t59->irq, &pdev->dev);
	platform_set_drvdata(pdev, NULL);
	kfree(m48t59);
	return 0;
}

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

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

static int __init m48t59_rtc_init(void)
{
	return platform_driver_register(&m48t59_rtc_driver);
}

static void __exit m48t59_rtc_exit(void)
{
	platform_driver_unregister(&m48t59_rtc_driver);
}

module_init(m48t59_rtc_init);
module_exit(m48t59_rtc_exit);

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);
	71	struct m48t59_plat_data *pdata = pdev->dev.platform_data;
	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);
	108	return 0;
	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);
	114	struct m48t59_plat_data *pdata = pdev->dev.platform_data;
	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);
	161	struct m48t59_plat_data *pdata = pdev->dev.platform_data;
	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);
	199	return 0;
	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);
	208	struct m48t59_plat_data *pdata = pdev->dev.platform_data;
	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	*/
	266	static int m48t59_rtc_ioctl(struct device *dev, unsigned int cmd,
	267	unsigned long arg)
	268	{
	269	struct platform_device *pdev = to_platform_device(dev);
	270	struct m48t59_plat_data *pdata = pdev->dev.platform_data;
	271	struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
	272	unsigned long flags;
	273	int ret = 0;
	274
	275	spin_lock_irqsave(&m48t59->lock, flags);
	276	switch (cmd) {
	277	case RTC_AIE_OFF: /* alarm interrupt off */
	278	M48T59_WRITE(0x00, M48T59_INTR);
	279	break;
	280	case RTC_AIE_ON: /* alarm interrupt on */
	281	M48T59_WRITE(M48T59_INTR_AFE, M48T59_INTR);
	282	break;
	283	default:
	284	ret = -ENOIOCTLCMD;
	285	break;
	286	}
	287	spin_unlock_irqrestore(&m48t59->lock, flags);
	288
	289	return ret;
	290	}
	291
	292	static int m48t59_rtc_proc(struct device dev, struct seq_file seq)
	293	{
	294	struct platform_device *pdev = to_platform_device(dev);
	295	struct m48t59_plat_data *pdata = pdev->dev.platform_data;
	296	struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
	297	unsigned long flags;
	298	u8 val;
	299
	300	spin_lock_irqsave(&m48t59->lock, flags);
	301	val = M48T59_READ(M48T59_FLAGS);
	302	spin_unlock_irqrestore(&m48t59->lock, flags);
	303
	304	seq_printf(seq, "battery\t\t: %s\n",
	305	(val & M48T59_FLAGS_BF) ? "low" : "normal");
	306	return 0;
	307	}
	308
	309	/*
	310	* IRQ handler for the RTC
	311	*/
	312	static irqreturn_t m48t59_rtc_interrupt(int irq, void *dev_id)
	313	{
	314	struct device dev = (struct device )dev_id;
	315	struct platform_device *pdev = to_platform_device(dev);
	316	struct m48t59_plat_data *pdata = pdev->dev.platform_data;
	317	struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
	318	u8 event;
	319
	320	spin_lock(&m48t59->lock);
	321	event = M48T59_READ(M48T59_FLAGS);
	322	spin_unlock(&m48t59->lock);
323
324	if (event & M48T59_FLAGS_AF) {
325	rtc_update_irq(m48t59->rtc, 1, (RTC_AF \| RTC_IRQF));
326	return IRQ_HANDLED;
327	}
328
329	return IRQ_NONE;
330	}
331
332	static const struct rtc_class_ops m48t59_rtc_ops = {
333	.ioctl = m48t59_rtc_ioctl,
334	.read_time = m48t59_rtc_read_time,
335	.set_time = m48t59_rtc_set_time,
336	.read_alarm = m48t59_rtc_readalarm,
337	.set_alarm = m48t59_rtc_setalarm,
338	.proc = m48t59_rtc_proc,
339	};
340
94fe7424 KH	341	static const struct rtc_class_ops m48t02_rtc_ops = {
	342	.read_time = m48t59_rtc_read_time,
	343	.set_time = m48t59_rtc_set_time,
	344	};
	345
2e774c7c MZ	346	static ssize_t m48t59_nvram_read(struct kobject *kobj,
	347	struct bin_attribute *bin_attr,
	348	char *buf, loff_t pos, size_t size)
	349	{
	350	struct device *dev = container_of(kobj, struct device, kobj);
	351	struct platform_device *pdev = to_platform_device(dev);
	352	struct m48t59_plat_data *pdata = pdev->dev.platform_data;
	353	struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
	354	ssize_t cnt = 0;
	355	unsigned long flags;
	356
94fe7424	357	for (; size > 0 && pos < pdata->offset; cnt++, size--) {
2e774c7c MZ	358	spin_lock_irqsave(&m48t59->lock, flags);
	359	*buf++ = M48T59_READ(cnt);
	360	spin_unlock_irqrestore(&m48t59->lock, flags);
	361	}
	362
	363	return cnt;
	364	}
	365
	366	static ssize_t m48t59_nvram_write(struct kobject *kobj,
	367	struct bin_attribute *bin_attr,
	368	char *buf, loff_t pos, size_t size)
	369	{
	370	struct device *dev = container_of(kobj, struct device, kobj);
	371	struct platform_device *pdev = to_platform_device(dev);
	372	struct m48t59_plat_data *pdata = pdev->dev.platform_data;
	373	struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
	374	ssize_t cnt = 0;
	375	unsigned long flags;
	376
94fe7424	377	for (; size > 0 && pos < pdata->offset; cnt++, size--) {
2e774c7c MZ	378	spin_lock_irqsave(&m48t59->lock, flags);
	379	M48T59_WRITE(*buf++, cnt);
	380	spin_unlock_irqrestore(&m48t59->lock, flags);
	381	}
	382
	383	return cnt;
	384	}
	385
	386	static struct bin_attribute m48t59_nvram_attr = {
	387	.attr = {
	388	.name = "nvram",
a4b1d50e	389	.mode = S_IRUGO \| S_IWUSR,
2e774c7c MZ	390	},
	391	.read = m48t59_nvram_read,
	392	.write = m48t59_nvram_write,
	393	};
	394
	395	static int __devinit m48t59_rtc_probe(struct platform_device *pdev)
	396	{
	397	struct m48t59_plat_data *pdata = pdev->dev.platform_data;
	398	struct m48t59_private *m48t59 = NULL;
	399	struct resource *res;
	400	int ret = -ENOMEM;
94fe7424 KH	401	char *name;
94fe7424 KH	402	const struct rtc_class_ops *ops;
2e774c7c MZ	403
	404	/* This chip could be memory-mapped or I/O-mapped */
	405	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	406	if (!res) {
	407	res = platform_get_resource(pdev, IORESOURCE_IO, 0);
	408	if (!res)
	409	return -EINVAL;
	410	}
	411
	412	if (res->flags & IORESOURCE_IO) {
	413	/* If we are I/O-mapped, the platform should provide
	414	* the operations accessing chip registers.
	415	*/
	416	if (!pdata \|\| !pdata->write_byte \|\| !pdata->read_byte)
	417	return -EINVAL;
	418	} else if (res->flags & IORESOURCE_MEM) {
	419	/* we are memory-mapped */
	420	if (!pdata) {
	421	pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
	422	if (!pdata)
	423	return -ENOMEM;
	424	/* Ensure we only kmalloc platform data once */
	425	pdev->dev.platform_data = pdata;
	426	}
94fe7424 KH	427	if (!pdata->type)
94fe7424 KH	428	pdata->type = M48T59RTC_TYPE_M48T59;
2e774c7c MZ	429
	430	/* Try to use the generic memory read/write ops */
	431	if (!pdata->write_byte)
	432	pdata->write_byte = m48t59_mem_writeb;
	433	if (!pdata->read_byte)
	434	pdata->read_byte = m48t59_mem_readb;
	435	}
	436
	437	m48t59 = kzalloc(sizeof(*m48t59), GFP_KERNEL);
	438	if (!m48t59)
	439	return -ENOMEM;
	440
64151ad5 KH	441	m48t59->ioaddr = pdata->ioaddr;
	442
	443	if (!m48t59->ioaddr) {
	444	/* ioaddr not mapped externally */
	445	m48t59->ioaddr = ioremap(res->start, res->end - res->start + 1);
	446	if (!m48t59->ioaddr)
	447	goto out;
	448	}
2e774c7c MZ	449
	450	/* Try to get irq number. We also can work in
	451	* the mode without IRQ.
	452	*/
	453	m48t59->irq = platform_get_irq(pdev, 0);
2fac6674	454	if (m48t59->irq <= 0)
2e774c7c MZ	455	m48t59->irq = NO_IRQ;
	456
	457	if (m48t59->irq != NO_IRQ) {
	458	ret = request_irq(m48t59->irq, m48t59_rtc_interrupt,
	459	IRQF_SHARED, "rtc-m48t59", &pdev->dev);
	460	if (ret)
	461	goto out;
	462	}
94fe7424 KH	463	switch (pdata->type) {
	464	case M48T59RTC_TYPE_M48T59:
	465	name = "m48t59";
	466	ops = &m48t59_rtc_ops;
	467	pdata->offset = 0x1ff0;
	468	break;
	469	case M48T59RTC_TYPE_M48T02:
	470	name = "m48t02";
	471	ops = &m48t02_rtc_ops;
	472	pdata->offset = 0x7f0;
	473	break;
	474	case M48T59RTC_TYPE_M48T08:
	475	name = "m48t08";
	476	ops = &m48t02_rtc_ops;
	477	pdata->offset = 0x1ff0;
	478	break;
	479	default:
	480	dev_err(&pdev->dev, "Unknown RTC type\n");
	481	ret = -ENODEV;
	482	goto out;
	483	}
2e774c7c	484
b74d2caa AZ	485	spin_lock_init(&m48t59->lock);
	486	platform_set_drvdata(pdev, m48t59);
	487
94fe7424	488	m48t59->rtc = rtc_device_register(name, &pdev->dev, ops, THIS_MODULE);
2e774c7c MZ	489	if (IS_ERR(m48t59->rtc)) {
	490	ret = PTR_ERR(m48t59->rtc);
	491	goto out;
	492	}
	493
94fe7424 KH	494	m48t59_nvram_attr.size = pdata->offset;
94fe7424 KH	495
2e774c7c	496	ret = sysfs_create_bin_file(&pdev->dev.kobj, &m48t59_nvram_attr);
b74d2caa AZ	497	if (ret) {
b74d2caa AZ	498	rtc_device_unregister(m48t59->rtc);
2e774c7c	499	goto out;
b74d2caa	500	}
2e774c7c	501
2e774c7c MZ	502	return 0;
	503
	504	out:
2e774c7c MZ	505	if (m48t59->irq != NO_IRQ)
	506	free_irq(m48t59->irq, &pdev->dev);
	507	if (m48t59->ioaddr)
	508	iounmap(m48t59->ioaddr);
	509	if (m48t59)
	510	kfree(m48t59);
	511	return ret;
	512	}
	513
	514	static int __devexit m48t59_rtc_remove(struct platform_device *pdev)
	515	{
	516	struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
64151ad5	517	struct m48t59_plat_data *pdata = pdev->dev.platform_data;
2e774c7c MZ	518
	519	sysfs_remove_bin_file(&pdev->dev.kobj, &m48t59_nvram_attr);
	520	if (!IS_ERR(m48t59->rtc))
	521	rtc_device_unregister(m48t59->rtc);
64151ad5	522	if (m48t59->ioaddr && !pdata->ioaddr)
2e774c7c MZ	523	iounmap(m48t59->ioaddr);
	524	if (m48t59->irq != NO_IRQ)
	525	free_irq(m48t59->irq, &pdev->dev);
	526	platform_set_drvdata(pdev, NULL);
	527	kfree(m48t59);
	528	return 0;
	529	}
	530
ad28a07b KS	531	/* work with hotplug and coldplug */
	532	MODULE_ALIAS("platform:rtc-m48t59");
	533
12730926	534	static struct platform_driver m48t59_rtc_driver = {
2e774c7c MZ	535	.driver = {
	536	.name = "rtc-m48t59",
	537	.owner = THIS_MODULE,
	538	},
	539	.probe = m48t59_rtc_probe,
	540	.remove = __devexit_p(m48t59_rtc_remove),
	541	};
	542
	543	static int __init m48t59_rtc_init(void)
	544	{
12730926	545	return platform_driver_register(&m48t59_rtc_driver);
2e774c7c MZ	546	}
	547
	548	static void __exit m48t59_rtc_exit(void)
	549	{
12730926	550	platform_driver_unregister(&m48t59_rtc_driver);
2e774c7c MZ	551	}
	552
	553	module_init(m48t59_rtc_init);
	554	module_exit(m48t59_rtc_exit);
	555
	556	MODULE_AUTHOR("Mark Zhan <rongkai.zhan@windriver.com>");
94fe7424	557	MODULE_DESCRIPTION("M48T59/M48T02/M48T08 RTC driver");
2e774c7c	558	MODULE_LICENSE("GPL");