some kmalloc/memset ->kzalloc (tree wide)
[linux-2.6.git] / 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
16 #include <linux/platform_device.h>
17 #include <linux/module.h>
18 #include <linux/rtc.h>
19 #include <linux/init.h>
20 #include <linux/fs.h>
21 #include <linux/interrupt.h>
22 #include <linux/string.h>
23 #include <linux/pm.h>
24
25 #include <linux/amba/bus.h>
26
27 #include <asm/io.h>
28 #include <asm/bitops.h>
29 #include <asm/hardware.h>
30 #include <asm/irq.h>
31 #include <asm/rtc.h>
32
33 /*
34  * Register definitions
35  */
36 #define RTC_DR          0x00    /* Data read register */
37 #define RTC_MR          0x04    /* Match register */
38 #define RTC_LR          0x08    /* Data load register */
39 #define RTC_CR          0x0c    /* Control register */
40 #define RTC_IMSC        0x10    /* Interrupt mask and set register */
41 #define RTC_RIS         0x14    /* Raw interrupt status register */
42 #define RTC_MIS         0x18    /* Masked interrupt status register */
43 #define RTC_ICR         0x1c    /* Interrupt clear register */
44
45 struct pl031_local {
46         struct rtc_device *rtc;
47         void __iomem *base;
48 };
49
50 static irqreturn_t pl031_interrupt(int irq, void *dev_id)
51 {
52         struct rtc_device *rtc = dev_id;
53
54         rtc_update_irq(rtc, 1, RTC_AF);
55
56         return IRQ_HANDLED;
57 }
58
59 static int pl031_open(struct device *dev)
60 {
61         /*
62          * We request IRQ in pl031_probe, so nothing to do here...
63          */
64         return 0;
65 }
66
67 static void pl031_release(struct device *dev)
68 {
69 }
70
71 static int pl031_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
72 {
73         struct pl031_local *ldata = dev_get_drvdata(dev);
74
75         switch (cmd) {
76         case RTC_AIE_OFF:
77                 __raw_writel(1, ldata->base + RTC_MIS);
78                 return 0;
79         case RTC_AIE_ON:
80                 __raw_writel(0, ldata->base + RTC_MIS);
81                 return 0;
82         }
83
84         return -ENOIOCTLCMD;
85 }
86
87 static int pl031_read_time(struct device *dev, struct rtc_time *tm)
88 {
89         struct pl031_local *ldata = dev_get_drvdata(dev);
90
91         rtc_time_to_tm(__raw_readl(ldata->base + RTC_DR), tm);
92
93         return 0;
94 }
95
96 static int pl031_set_time(struct device *dev, struct rtc_time *tm)
97 {
98         unsigned long time;
99         struct pl031_local *ldata = dev_get_drvdata(dev);
100
101         rtc_tm_to_time(tm, &time);
102         __raw_writel(time, ldata->base + RTC_LR);
103
104         return 0;
105 }
106
107 static int pl031_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
108 {
109         struct pl031_local *ldata = dev_get_drvdata(dev);
110
111         rtc_time_to_tm(__raw_readl(ldata->base + RTC_MR), &alarm->time);
112         alarm->pending = __raw_readl(ldata->base + RTC_RIS);
113         alarm->enabled = __raw_readl(ldata->base + RTC_IMSC);
114
115         return 0;
116 }
117
118 static int pl031_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
119 {
120         struct pl031_local *ldata = dev_get_drvdata(dev);
121         unsigned long time;
122
123         rtc_tm_to_time(&alarm->time, &time);
124
125         __raw_writel(time, ldata->base + RTC_MR);
126         __raw_writel(!alarm->enabled, ldata->base + RTC_MIS);
127
128         return 0;
129 }
130
131 static const struct rtc_class_ops pl031_ops = {
132         .open = pl031_open,
133         .release = pl031_release,
134         .ioctl = pl031_ioctl,
135         .read_time = pl031_read_time,
136         .set_time = pl031_set_time,
137         .read_alarm = pl031_read_alarm,
138         .set_alarm = pl031_set_alarm,
139 };
140
141 static int pl031_remove(struct amba_device *adev)
142 {
143         struct pl031_local *ldata = dev_get_drvdata(&adev->dev);
144
145         if (ldata) {
146                 dev_set_drvdata(&adev->dev, NULL);
147                 free_irq(adev->irq[0], ldata->rtc);
148                 rtc_device_unregister(ldata->rtc);
149                 iounmap(ldata->base);
150                 kfree(ldata);
151         }
152
153         return 0;
154 }
155
156 static int pl031_probe(struct amba_device *adev, void *id)
157 {
158         int ret;
159         struct pl031_local *ldata;
160
161
162         ldata = kmalloc(sizeof(struct pl031_local), GFP_KERNEL);
163         if (!ldata) {
164                 ret = -ENOMEM;
165                 goto out;
166         }
167         dev_set_drvdata(&adev->dev, ldata);
168
169         ldata->base = ioremap(adev->res.start,
170                               adev->res.end - adev->res.start + 1);
171         if (!ldata->base) {
172                 ret = -ENOMEM;
173                 goto out_no_remap;
174         }
175
176         if (request_irq(adev->irq[0], pl031_interrupt, IRQF_DISABLED,
177                         "rtc-pl031", ldata->rtc)) {
178                 ret = -EIO;
179                 goto out_no_irq;
180         }
181
182         ldata->rtc = rtc_device_register("pl031", &adev->dev, &pl031_ops,
183                                          THIS_MODULE);
184         if (IS_ERR(ldata->rtc)) {
185                 ret = PTR_ERR(ldata->rtc);
186                 goto out_no_rtc;
187         }
188
189         return 0;
190
191 out_no_rtc:
192         free_irq(adev->irq[0], ldata->rtc);
193 out_no_irq:
194         iounmap(ldata->base);
195 out_no_remap:
196         dev_set_drvdata(&adev->dev, NULL);
197         kfree(ldata);
198 out:
199         return ret;
200 }
201
202 static struct amba_id pl031_ids[] __initdata = {
203         {
204                  .id = 0x00041031,
205                 .mask = 0x000fffff, },
206         {0, 0},
207 };
208
209 static struct amba_driver pl031_driver = {
210         .drv = {
211                 .name = "rtc-pl031",
212         },
213         .id_table = pl031_ids,
214         .probe = pl031_probe,
215         .remove = pl031_remove,
216 };
217
218 static int __init pl031_init(void)
219 {
220         return amba_driver_register(&pl031_driver);
221 }
222
223 static void __exit pl031_exit(void)
224 {
225         amba_driver_unregister(&pl031_driver);
226 }
227
228 module_init(pl031_init);
229 module_exit(pl031_exit);
230
231 MODULE_AUTHOR("Deepak Saxena <dsaxena@plexity.net");
232 MODULE_DESCRIPTION("ARM AMBA PL031 RTC Driver");
233 MODULE_LICENSE("GPL");