Merge commit 'kumar/next' into next
[linux-2.6] / drivers / rtc / rtc-pl031.c
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  */
15 #include <linux/module.h>
16 #include <linux/rtc.h>
17 #include <linux/init.h>
18 #include <linux/interrupt.h>
19 #include <linux/amba/bus.h>
20 #include <linux/io.h>
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
39 static irqreturn_t pl031_interrupt(int irq, void *dev_id)
40 {
41         struct rtc_device *rtc = dev_id;
42
43         rtc_update_irq(rtc, 1, RTC_AF);
44
45         return IRQ_HANDLED;
46 }
47
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:
54                 __raw_writel(1, ldata->base + RTC_MIS);
55                 return 0;
56         case RTC_AIE_ON:
57                 __raw_writel(0, ldata->base + RTC_MIS);
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
68         rtc_time_to_tm(__raw_readl(ldata->base + RTC_DR), tm);
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);
79         __raw_writel(time, ldata->base + RTC_LR);
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
88         rtc_time_to_tm(__raw_readl(ldata->base + RTC_MR), &alarm->time);
89         alarm->pending = __raw_readl(ldata->base + RTC_RIS);
90         alarm->enabled = __raw_readl(ldata->base + RTC_IMSC);
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
102         __raw_writel(time, ldata->base + RTC_MR);
103         __raw_writel(!alarm->enabled, ldata->base + RTC_MIS);
104
105         return 0;
106 }
107
108 static const struct rtc_class_ops pl031_ops = {
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
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);
126
127         return 0;
128 }
129
130 static int pl031_probe(struct amba_device *adev, void *id)
131 {
132         int ret;
133         struct pl031_local *ldata;
134
135         ret = amba_request_regions(adev, NULL);
136         if (ret)
137                 goto err_req;
138
139         ldata = kmalloc(sizeof(struct pl031_local), GFP_KERNEL);
140         if (!ldata) {
141                 ret = -ENOMEM;
142                 goto out;
143         }
144
145         ldata->base = ioremap(adev->res.start,
146                               adev->res.end - adev->res.start + 1);
147         if (!ldata->base) {
148                 ret = -ENOMEM;
149                 goto out_no_remap;
150         }
151
152         amba_set_drvdata(adev, ldata);
153
154         if (request_irq(adev->irq[0], pl031_interrupt, IRQF_DISABLED,
155                         "rtc-pl031", ldata->rtc)) {
156                 ret = -EIO;
157                 goto out_no_irq;
158         }
159
160         ldata->rtc = rtc_device_register("pl031", &adev->dev, &pl031_ops,
161                                          THIS_MODULE);
162         if (IS_ERR(ldata->rtc)) {
163                 ret = PTR_ERR(ldata->rtc);
164                 goto out_no_rtc;
165         }
166
167         return 0;
168
169 out_no_rtc:
170         free_irq(adev->irq[0], ldata->rtc);
171 out_no_irq:
172         iounmap(ldata->base);
173         amba_set_drvdata(adev, NULL);
174 out_no_remap:
175         kfree(ldata);
176 out:
177         amba_release_regions(adev);
178 err_req:
179         return ret;
180 }
181
182 static struct amba_id pl031_ids[] __initdata = {
183         {
184                  .id = 0x00041031,
185                 .mask = 0x000fffff, },
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");