[deliverable/linux.git] / drivers / rtc / rtc-pl031.c

/*
 * drivers/rtc/rtc-pl031.c
 *
 * Real Time Clock interface for ARM AMBA PrimeCell 031 RTC
 *
 * Author: Deepak Saxena <dsaxena@plexity.net>
 *
 * Copyright 2006 (c) MontaVista Software, Inc.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version
 * 2 of the License, or (at your option) any later version.
 */
#include <linux/module.h>
#include <linux/rtc.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/amba/bus.h>
#include <linux/io.h>

/*
 * Register definitions
 */
#define	RTC_DR		0x00	/* Data read register */
#define	RTC_MR		0x04	/* Match register */
#define	RTC_LR		0x08	/* Data load register */
#define	RTC_CR		0x0c	/* Control register */
#define	RTC_IMSC	0x10	/* Interrupt mask and set register */
#define	RTC_RIS		0x14	/* Raw interrupt status register */
#define	RTC_MIS		0x18	/* Masked interrupt status register */
#define	RTC_ICR		0x1c	/* Interrupt clear register */

struct pl031_local {
	struct rtc_device *rtc;
	void __iomem *base;
};

static irqreturn_t pl031_interrupt(int irq, void *dev_id)
{
	struct rtc_device *rtc = dev_id;

	rtc_update_irq(rtc, 1, RTC_AF);

	return IRQ_HANDLED;
}

static int pl031_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
{
	struct pl031_local *ldata = dev_get_drvdata(dev);

	switch (cmd) {
	case RTC_AIE_OFF:
		writel(1, ldata->base + RTC_MIS);
		return 0;
	case RTC_AIE_ON:
		writel(0, ldata->base + RTC_MIS);
		return 0;
	}

	return -ENOIOCTLCMD;
}

static int pl031_read_time(struct device *dev, struct rtc_time *tm)
{
	struct pl031_local *ldata = dev_get_drvdata(dev);

	rtc_time_to_tm(readl(ldata->base + RTC_DR), tm);

	return 0;
}

static int pl031_set_time(struct device *dev, struct rtc_time *tm)
{
	unsigned long time;
	struct pl031_local *ldata = dev_get_drvdata(dev);

	rtc_tm_to_time(tm, &time);
	writel(time, ldata->base + RTC_LR);

	return 0;
}

static int pl031_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
{
	struct pl031_local *ldata = dev_get_drvdata(dev);

	rtc_time_to_tm(readl(ldata->base + RTC_MR), &alarm->time);
	alarm->pending = readl(ldata->base + RTC_RIS);
	alarm->enabled = readl(ldata->base + RTC_IMSC);

	return 0;
}

static int pl031_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
{
	struct pl031_local *ldata = dev_get_drvdata(dev);
	unsigned long time;

	rtc_tm_to_time(&alarm->time, &time);

	writel(time, ldata->base + RTC_MR);
	writel(!alarm->enabled, ldata->base + RTC_MIS);

	return 0;
}

static const struct rtc_class_ops pl031_ops = {
	.ioctl = pl031_ioctl,
	.read_time = pl031_read_time,
	.set_time = pl031_set_time,
	.read_alarm = pl031_read_alarm,
	.set_alarm = pl031_set_alarm,
};

static int pl031_remove(struct amba_device *adev)
{
	struct pl031_local *ldata = dev_get_drvdata(&adev->dev);

	amba_set_drvdata(adev, NULL);
	free_irq(adev->irq[0], ldata->rtc);
	rtc_device_unregister(ldata->rtc);
	iounmap(ldata->base);
	kfree(ldata);
	amba_release_regions(adev);

	return 0;
}

static int pl031_probe(struct amba_device *adev, struct amba_id *id)
{
	int ret;
	struct pl031_local *ldata;

	ret = amba_request_regions(adev, NULL);
	if (ret)
		goto err_req;

	ldata = kmalloc(sizeof(struct pl031_local), GFP_KERNEL);
	if (!ldata) {
		ret = -ENOMEM;
		goto out;
	}

	ldata->base = ioremap(adev->res.start, resource_size(&adev->res));
	if (!ldata->base) {
		ret = -ENOMEM;
		goto out_no_remap;
	}

	amba_set_drvdata(adev, ldata);

	if (request_irq(adev->irq[0], pl031_interrupt, IRQF_DISABLED,
			"rtc-pl031", ldata->rtc)) {
		ret = -EIO;
		goto out_no_irq;
	}

	ldata->rtc = rtc_device_register("pl031", &adev->dev, &pl031_ops,
					 THIS_MODULE);
	if (IS_ERR(ldata->rtc)) {
		ret = PTR_ERR(ldata->rtc);
		goto out_no_rtc;
	}

	return 0;

out_no_rtc:
	free_irq(adev->irq[0], ldata->rtc);
out_no_irq:
	iounmap(ldata->base);
	amba_set_drvdata(adev, NULL);
out_no_remap:
	kfree(ldata);
out:
	amba_release_regions(adev);
err_req:
	return ret;
}

static struct amba_id pl031_ids[] __initdata = {
	{
		.id = 0x00041031,
		.mask = 0x000fffff,
	},
	{0, 0},
};

static struct amba_driver pl031_driver = {
	.drv = {
		.name = "rtc-pl031",
	},
	.id_table = pl031_ids,
	.probe = pl031_probe,
	.remove = pl031_remove,
};

static int __init pl031_init(void)
{
	return amba_driver_register(&pl031_driver);
}

static void __exit pl031_exit(void)
{
	amba_driver_unregister(&pl031_driver);
}

module_init(pl031_init);
module_exit(pl031_exit);

MODULE_AUTHOR("Deepak Saxena <dsaxena@plexity.net");
MODULE_DESCRIPTION("ARM AMBA PL031 RTC Driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
8ae6e163 DS	1	/*
	2	* drivers/rtc/rtc-pl031.c
	3	*
	4	* Real Time Clock interface for ARM AMBA PrimeCell 031 RTC
	5	*
	6	* Author: Deepak Saxena <dsaxena@plexity.net>
	7	*
	8	* Copyright 2006 (c) MontaVista Software, Inc.
	9	*
	10	* This program is free software; you can redistribute it and/or
	11	* modify it under the terms of the GNU General Public License
	12	* as published by the Free Software Foundation; either version
	13	* 2 of the License, or (at your option) any later version.
	14	*/
8ae6e163 DS	15	#include <linux/module.h>
	16	#include <linux/rtc.h>
	17	#include <linux/init.h>
8ae6e163	18	#include <linux/interrupt.h>
8ae6e163	19	#include <linux/amba/bus.h>
2dba8518	20	#include <linux/io.h>
8ae6e163 DS	21
	22	/*
	23	* Register definitions
	24	*/
	25	#define RTC_DR 0x00 /* Data read register */
	26	#define RTC_MR 0x04 /* Match register */
	27	#define RTC_LR 0x08 /* Data load register */
	28	#define RTC_CR 0x0c /* Control register */
	29	#define RTC_IMSC 0x10 /* Interrupt mask and set register */
	30	#define RTC_RIS 0x14 /* Raw interrupt status register */
	31	#define RTC_MIS 0x18 /* Masked interrupt status register */
	32	#define RTC_ICR 0x1c /* Interrupt clear register */
	33
	34	struct pl031_local {
	35	struct rtc_device *rtc;
	36	void __iomem *base;
	37	};
	38
7d12e780	39	static irqreturn_t pl031_interrupt(int irq, void *dev_id)
8ae6e163 DS	40	{
	41	struct rtc_device *rtc = dev_id;
	42
ab6a2d70	43	rtc_update_irq(rtc, 1, RTC_AF);
8ae6e163 DS	44
	45	return IRQ_HANDLED;
	46	}
	47
8ae6e163 DS	48	static int pl031_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
	49	{
	50	struct pl031_local *ldata = dev_get_drvdata(dev);
	51
	52	switch (cmd) {
	53	case RTC_AIE_OFF:
2934d6a8	54	writel(1, ldata->base + RTC_MIS);
8ae6e163 DS	55	return 0;
8ae6e163 DS	56	case RTC_AIE_ON:
2934d6a8	57	writel(0, ldata->base + RTC_MIS);
8ae6e163 DS	58	return 0;
	59	}
	60
	61	return -ENOIOCTLCMD;
	62	}
	63
	64	static int pl031_read_time(struct device dev, struct rtc_time tm)
	65	{
	66	struct pl031_local *ldata = dev_get_drvdata(dev);
	67
2934d6a8	68	rtc_time_to_tm(readl(ldata->base + RTC_DR), tm);
8ae6e163 DS	69
	70	return 0;
	71	}
	72
	73	static int pl031_set_time(struct device dev, struct rtc_time tm)
	74	{
	75	unsigned long time;
	76	struct pl031_local *ldata = dev_get_drvdata(dev);
	77
	78	rtc_tm_to_time(tm, &time);
2934d6a8	79	writel(time, ldata->base + RTC_LR);
8ae6e163 DS	80
	81	return 0;
	82	}
	83
	84	static int pl031_read_alarm(struct device dev, struct rtc_wkalrm alarm)
	85	{
	86	struct pl031_local *ldata = dev_get_drvdata(dev);
	87
2934d6a8 LW	88	rtc_time_to_tm(readl(ldata->base + RTC_MR), &alarm->time);
	89	alarm->pending = readl(ldata->base + RTC_RIS);
	90	alarm->enabled = readl(ldata->base + RTC_IMSC);
8ae6e163 DS	91
	92	return 0;
	93	}
	94
	95	static int pl031_set_alarm(struct device dev, struct rtc_wkalrm alarm)
	96	{
	97	struct pl031_local *ldata = dev_get_drvdata(dev);
	98	unsigned long time;
	99
	100	rtc_tm_to_time(&alarm->time, &time);
	101
2934d6a8 LW	102	writel(time, ldata->base + RTC_MR);
2934d6a8 LW	103	writel(!alarm->enabled, ldata->base + RTC_MIS);
8ae6e163 DS	104
	105	return 0;
	106	}
	107
ff8371ac	108	static const struct rtc_class_ops pl031_ops = {
8ae6e163 DS	109	.ioctl = pl031_ioctl,
	110	.read_time = pl031_read_time,
	111	.set_time = pl031_set_time,
	112	.read_alarm = pl031_read_alarm,
	113	.set_alarm = pl031_set_alarm,
	114	};
	115
	116	static int pl031_remove(struct amba_device *adev)
	117	{
	118	struct pl031_local *ldata = dev_get_drvdata(&adev->dev);
	119
2dba8518 RK	120	amba_set_drvdata(adev, NULL);
	121	free_irq(adev->irq[0], ldata->rtc);
	122	rtc_device_unregister(ldata->rtc);
	123	iounmap(ldata->base);
	124	kfree(ldata);
	125	amba_release_regions(adev);
8ae6e163 DS	126
	127	return 0;
	128	}
	129
03fbdb15	130	static int pl031_probe(struct amba_device adev, struct amba_id id)
8ae6e163 DS	131	{
	132	int ret;
	133	struct pl031_local *ldata;
	134
2dba8518 RK	135	ret = amba_request_regions(adev, NULL);
	136	if (ret)
	137	goto err_req;
8ae6e163 DS	138
	139	ldata = kmalloc(sizeof(struct pl031_local), GFP_KERNEL);
	140	if (!ldata) {
	141	ret = -ENOMEM;
	142	goto out;
	143	}
8ae6e163	144
dc890c2d	145	ldata->base = ioremap(adev->res.start, resource_size(&adev->res));
8ae6e163 DS	146	if (!ldata->base) {
	147	ret = -ENOMEM;
	148	goto out_no_remap;
	149	}
	150
2dba8518 RK	151	amba_set_drvdata(adev, ldata);
2dba8518 RK	152
dace1453	153	if (request_irq(adev->irq[0], pl031_interrupt, IRQF_DISABLED,
8ae6e163 DS	154	"rtc-pl031", ldata->rtc)) {
	155	ret = -EIO;
	156	goto out_no_irq;
	157	}
	158
	159	ldata->rtc = rtc_device_register("pl031", &adev->dev, &pl031_ops,
	160	THIS_MODULE);
	161	if (IS_ERR(ldata->rtc)) {
	162	ret = PTR_ERR(ldata->rtc);
	163	goto out_no_rtc;
	164	}
	165
	166	return 0;
	167
	168	out_no_rtc:
	169	free_irq(adev->irq[0], ldata->rtc);
	170	out_no_irq:
	171	iounmap(ldata->base);
2dba8518	172	amba_set_drvdata(adev, NULL);
8ae6e163	173	out_no_remap:
8ae6e163 DS	174	kfree(ldata);
8ae6e163 DS	175	out:
2dba8518 RK	176	amba_release_regions(adev);
2dba8518 RK	177	err_req:
8ae6e163 DS	178	return ret;
	179	}
	180
	181	static struct amba_id pl031_ids[] __initdata = {
	182	{
2934d6a8 LW	183	.id = 0x00041031,
	184	.mask = 0x000fffff,
	185	},
8ae6e163 DS	186	{0, 0},
	187	};
	188
	189	static struct amba_driver pl031_driver = {
	190	.drv = {
	191	.name = "rtc-pl031",
	192	},
	193	.id_table = pl031_ids,
	194	.probe = pl031_probe,
	195	.remove = pl031_remove,
	196	};
	197
	198	static int __init pl031_init(void)
	199	{
	200	return amba_driver_register(&pl031_driver);
	201	}
	202
	203	static void __exit pl031_exit(void)
	204	{
	205	amba_driver_unregister(&pl031_driver);
	206	}
	207
	208	module_init(pl031_init);
	209	module_exit(pl031_exit);
	210
	211	MODULE_AUTHOR("Deepak Saxena <dsaxena@plexity.net");
	212	MODULE_DESCRIPTION("ARM AMBA PL031 RTC Driver");
	213	MODULE_LICENSE("GPL");