← Back to branch summary

~ubuntu-branches/ubuntu/trusty/linux-linaro-omap/trusty

« back to all changes in this revision

Viewing changes to drivers/rtc/rtc-vt8500.c

  • Committer: Package Import Robot
  • Author(s): John Rigby, John Rigby
  • Date: 2011-09-26 10:44:23 UTC
  • Revision ID: package-import@ubuntu.com-20110926104423-57i0gl3v99b3lkfg
Tags: 3.0.0-1007.9
https://launchpad.net/bugs/826021
[ John Rigby ]

Enable crypto modules and remove crypto-modules from
exclude-module files
LP: #826021

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/rtc/rtc-vt8500.c
 
1
/*
 
2
 * drivers/rtc/rtc-vt8500.c
 
3
 *
 
4
 *  Copyright (C) 2010 Alexey Charkov <alchark@gmail.com>
 
5
 *
 
6
 * Based on rtc-pxa.c
 
7
 *
 
8
 * This software is licensed under the terms of the GNU General Public
 
9
 * License version 2, as published by the Free Software Foundation, and
 
10
 * may be copied, distributed, and modified under those terms.
 
11
 *
 
12
 * This program is distributed in the hope that it will be useful,
 
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
15
 * GNU General Public License for more details.
 
16
 */
 
17
 
 
18
#include <linux/module.h>
 
19
#include <linux/rtc.h>
 
20
#include <linux/init.h>
 
21
#include <linux/interrupt.h>
 
22
#include <linux/io.h>
 
23
#include <linux/bcd.h>
 
24
#include <linux/platform_device.h>
 
25
#include <linux/slab.h>
 
26
 
 
27
/*
 
28
 * Register definitions
 
29
 */
 
30
#define VT8500_RTC_TS           0x00    /* Time set */
 
31
#define VT8500_RTC_DS           0x04    /* Date set */
 
32
#define VT8500_RTC_AS           0x08    /* Alarm set */
 
33
#define VT8500_RTC_CR           0x0c    /* Control */
 
34
#define VT8500_RTC_TR           0x10    /* Time read */
 
35
#define VT8500_RTC_DR           0x14    /* Date read */
 
36
#define VT8500_RTC_WS           0x18    /* Write status */
 
37
#define VT8500_RTC_CL           0x20    /* Calibration */
 
38
#define VT8500_RTC_IS           0x24    /* Interrupt status */
 
39
#define VT8500_RTC_ST           0x28    /* Status */
 
40
 
 
41
#define INVALID_TIME_BIT        (1 << 31)
 
42
 
 
43
#define DATE_CENTURY_S          19
 
44
#define DATE_YEAR_S             11
 
45
#define DATE_YEAR_MASK          (0xff << DATE_YEAR_S)
 
46
#define DATE_MONTH_S            6
 
47
#define DATE_MONTH_MASK         (0x1f << DATE_MONTH_S)
 
48
#define DATE_DAY_MASK           0x3f
 
49
 
 
50
#define TIME_DOW_S              20
 
51
#define TIME_DOW_MASK           (0x07 << TIME_DOW_S)
 
52
#define TIME_HOUR_S             14
 
53
#define TIME_HOUR_MASK          (0x3f << TIME_HOUR_S)
 
54
#define TIME_MIN_S              7
 
55
#define TIME_MIN_MASK           (0x7f << TIME_MIN_S)
 
56
#define TIME_SEC_MASK           0x7f
 
57
 
 
58
#define ALARM_DAY_S             20
 
59
#define ALARM_DAY_MASK          (0x3f << ALARM_DAY_S)
 
60
 
 
61
#define ALARM_DAY_BIT           (1 << 29)
 
62
#define ALARM_HOUR_BIT          (1 << 28)
 
63
#define ALARM_MIN_BIT           (1 << 27)
 
64
#define ALARM_SEC_BIT           (1 << 26)
 
65
 
 
66
#define ALARM_ENABLE_MASK       (ALARM_DAY_BIT \
 
67
                                | ALARM_HOUR_BIT \
 
68
                                | ALARM_MIN_BIT \
 
69
                                | ALARM_SEC_BIT)
 
70
 
 
71
#define VT8500_RTC_CR_ENABLE    (1 << 0)        /* Enable RTC */
 
72
#define VT8500_RTC_CR_24H       (1 << 1)        /* 24h time format */
 
73
#define VT8500_RTC_CR_SM_ENABLE (1 << 2)        /* Enable periodic irqs */
 
74
#define VT8500_RTC_CR_SM_SEC    (1 << 3)        /* 0: 1Hz/60, 1: 1Hz */
 
75
#define VT8500_RTC_CR_CALIB     (1 << 4)        /* Enable calibration */
 
76
 
 
77
struct vt8500_rtc {
 
78
        void __iomem            *regbase;
 
79
        struct resource         *res;
 
80
        int                     irq_alarm;
 
81
        struct rtc_device       *rtc;
 
82
        spinlock_t              lock;           /* Protects this structure */
 
83
};
 
84
 
 
85
static irqreturn_t vt8500_rtc_irq(int irq, void *dev_id)
 
86
{
 
87
        struct vt8500_rtc *vt8500_rtc = dev_id;
 
88
        u32 isr;
 
89
        unsigned long events = 0;
 
90
 
 
91
        spin_lock(&vt8500_rtc->lock);
 
92
 
 
93
        /* clear interrupt sources */
 
94
        isr = readl(vt8500_rtc->regbase + VT8500_RTC_IS);
 
95
        writel(isr, vt8500_rtc->regbase + VT8500_RTC_IS);
 
96
 
 
97
        spin_unlock(&vt8500_rtc->lock);
 
98
 
 
99
        if (isr & 1)
 
100
                events |= RTC_AF | RTC_IRQF;
 
101
 
 
102
        rtc_update_irq(vt8500_rtc->rtc, 1, events);
 
103
 
 
104
        return IRQ_HANDLED;
 
105
}
 
106
 
 
107
static int vt8500_rtc_read_time(struct device *dev, struct rtc_time *tm)
 
108
{
 
109
        struct vt8500_rtc *vt8500_rtc = dev_get_drvdata(dev);
 
110
        u32 date, time;
 
111
 
 
112
        date = readl(vt8500_rtc->regbase + VT8500_RTC_DR);
 
113
        time = readl(vt8500_rtc->regbase + VT8500_RTC_TR);
 
114
 
 
115
        tm->tm_sec = bcd2bin(time & TIME_SEC_MASK);
 
116
        tm->tm_min = bcd2bin((time & TIME_MIN_MASK) >> TIME_MIN_S);
 
117
        tm->tm_hour = bcd2bin((time & TIME_HOUR_MASK) >> TIME_HOUR_S);
 
118
        tm->tm_mday = bcd2bin(date & DATE_DAY_MASK);
 
119
        tm->tm_mon = bcd2bin((date & DATE_MONTH_MASK) >> DATE_MONTH_S);
 
120
        tm->tm_year = bcd2bin((date & DATE_YEAR_MASK) >> DATE_YEAR_S)
 
121
                        + ((date >> DATE_CENTURY_S) & 1 ? 200 : 100);
 
122
        tm->tm_wday = (time & TIME_DOW_MASK) >> TIME_DOW_S;
 
123
 
 
124
        return 0;
 
125
}
 
126
 
 
127
static int vt8500_rtc_set_time(struct device *dev, struct rtc_time *tm)
 
128
{
 
129
        struct vt8500_rtc *vt8500_rtc = dev_get_drvdata(dev);
 
130
 
 
131
        if (tm->tm_year < 100) {
 
132
                dev_warn(dev, "Only years 2000-2199 are supported by the "
 
133
                              "hardware!\n");
 
134
                return -EINVAL;
 
135
        }
 
136
 
 
137
        writel((bin2bcd(tm->tm_year - 100) << DATE_YEAR_S)
 
138
                | (bin2bcd(tm->tm_mon) << DATE_MONTH_S)
 
139
                | (bin2bcd(tm->tm_mday)),
 
140
                vt8500_rtc->regbase + VT8500_RTC_DS);
 
141
        writel((bin2bcd(tm->tm_wday) << TIME_DOW_S)
 
142
                | (bin2bcd(tm->tm_hour) << TIME_HOUR_S)
 
143
                | (bin2bcd(tm->tm_min) << TIME_MIN_S)
 
144
                | (bin2bcd(tm->tm_sec)),
 
145
                vt8500_rtc->regbase + VT8500_RTC_TS);
 
146
 
 
147
        return 0;
 
148
}
 
149
 
 
150
static int vt8500_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
 
151
{
 
152
        struct vt8500_rtc *vt8500_rtc = dev_get_drvdata(dev);
 
153
        u32 isr, alarm;
 
154
 
 
155
        alarm = readl(vt8500_rtc->regbase + VT8500_RTC_AS);
 
156
        isr = readl(vt8500_rtc->regbase + VT8500_RTC_IS);
 
157
 
 
158
        alrm->time.tm_mday = bcd2bin((alarm & ALARM_DAY_MASK) >> ALARM_DAY_S);
 
159
        alrm->time.tm_hour = bcd2bin((alarm & TIME_HOUR_MASK) >> TIME_HOUR_S);
 
160
        alrm->time.tm_min = bcd2bin((alarm & TIME_MIN_MASK) >> TIME_MIN_S);
 
161
        alrm->time.tm_sec = bcd2bin((alarm & TIME_SEC_MASK));
 
162
 
 
163
        alrm->enabled = (alarm & ALARM_ENABLE_MASK) ? 1 : 0;
 
164
 
 
165
        alrm->pending = (isr & 1) ? 1 : 0;
 
166
        return rtc_valid_tm(&alrm->time);
 
167
}
 
168
 
 
169
static int vt8500_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
 
170
{
 
171
        struct vt8500_rtc *vt8500_rtc = dev_get_drvdata(dev);
 
172
 
 
173
        writel((alrm->enabled ? ALARM_ENABLE_MASK : 0)
 
174
                | (bin2bcd(alrm->time.tm_mday) << ALARM_DAY_S)
 
175
                | (bin2bcd(alrm->time.tm_hour) << TIME_HOUR_S)
 
176
                | (bin2bcd(alrm->time.tm_min) << TIME_MIN_S)
 
177
                | (bin2bcd(alrm->time.tm_sec)),
 
178
                vt8500_rtc->regbase + VT8500_RTC_AS);
 
179
 
 
180
        return 0;
 
181
}
 
182
 
 
183
static int vt8500_alarm_irq_enable(struct device *dev, unsigned int enabled)
 
184
{
 
185
        struct vt8500_rtc *vt8500_rtc = dev_get_drvdata(dev);
 
186
        unsigned long tmp = readl(vt8500_rtc->regbase + VT8500_RTC_AS);
 
187
 
 
188
        if (enabled)
 
189
                tmp |= ALARM_ENABLE_MASK;
 
190
        else
 
191
                tmp &= ~ALARM_ENABLE_MASK;
 
192
 
 
193
        writel(tmp, vt8500_rtc->regbase + VT8500_RTC_AS);
 
194
        return 0;
 
195
}
 
196
 
 
197
static const struct rtc_class_ops vt8500_rtc_ops = {
 
198
        .read_time = vt8500_rtc_read_time,
 
199
        .set_time = vt8500_rtc_set_time,
 
200
        .read_alarm = vt8500_rtc_read_alarm,
 
201
        .set_alarm = vt8500_rtc_set_alarm,
 
202
        .alarm_irq_enable = vt8500_alarm_irq_enable,
 
203
};
 
204
 
 
205
static int __devinit vt8500_rtc_probe(struct platform_device *pdev)
 
206
{
 
207
        struct vt8500_rtc *vt8500_rtc;
 
208
        int ret;
 
209
 
 
210
        vt8500_rtc = kzalloc(sizeof(struct vt8500_rtc), GFP_KERNEL);
 
211
        if (!vt8500_rtc)
 
212
                return -ENOMEM;
 
213
 
 
214
        spin_lock_init(&vt8500_rtc->lock);
 
215
        platform_set_drvdata(pdev, vt8500_rtc);
 
216
 
 
217
        vt8500_rtc->res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 
218
        if (!vt8500_rtc->res) {
 
219
                dev_err(&pdev->dev, "No I/O memory resource defined\n");
 
220
                ret = -ENXIO;
 
221
                goto err_free;
 
222
        }
 
223
 
 
224
        vt8500_rtc->irq_alarm = platform_get_irq(pdev, 0);
 
225
        if (vt8500_rtc->irq_alarm < 0) {
 
226
                dev_err(&pdev->dev, "No alarm IRQ resource defined\n");
 
227
                ret = -ENXIO;
 
228
                goto err_free;
 
229
        }
 
230
 
 
231
        vt8500_rtc->res = request_mem_region(vt8500_rtc->res->start,
 
232
                                             resource_size(vt8500_rtc->res),
 
233
                                             "vt8500-rtc");
 
234
        if (vt8500_rtc->res == NULL) {
 
235
                dev_err(&pdev->dev, "failed to request I/O memory\n");
 
236
                ret = -EBUSY;
 
237
                goto err_free;
 
238
        }
 
239
 
 
240
        vt8500_rtc->regbase = ioremap(vt8500_rtc->res->start,
 
241
                                      resource_size(vt8500_rtc->res));
 
242
        if (!vt8500_rtc->regbase) {
 
243
                dev_err(&pdev->dev, "Unable to map RTC I/O memory\n");
 
244
                ret = -EBUSY;
 
245
                goto err_release;
 
246
        }
 
247
 
 
248
        /* Enable RTC and set it to 24-hour mode */
 
249
        writel(VT8500_RTC_CR_ENABLE | VT8500_RTC_CR_24H,
 
250
               vt8500_rtc->regbase + VT8500_RTC_CR);
 
251
 
 
252
        vt8500_rtc->rtc = rtc_device_register("vt8500-rtc", &pdev->dev,
 
253
                                              &vt8500_rtc_ops, THIS_MODULE);
 
254
        if (IS_ERR(vt8500_rtc->rtc)) {
 
255
                ret = PTR_ERR(vt8500_rtc->rtc);
 
256
                dev_err(&pdev->dev,
 
257
                        "Failed to register RTC device -> %d\n", ret);
 
258
                goto err_unmap;
 
259
        }
 
260
 
 
261
        ret = request_irq(vt8500_rtc->irq_alarm, vt8500_rtc_irq, 0,
 
262
                          "rtc alarm", vt8500_rtc);
 
263
        if (ret < 0) {
 
264
                dev_err(&pdev->dev, "can't get irq %i, err %d\n",
 
265
                        vt8500_rtc->irq_alarm, ret);
 
266
                goto err_unreg;
 
267
        }
 
268
 
 
269
        return 0;
 
270
 
 
271
err_unreg:
 
272
        rtc_device_unregister(vt8500_rtc->rtc);
 
273
err_unmap:
 
274
        iounmap(vt8500_rtc->regbase);
 
275
err_release:
 
276
        release_mem_region(vt8500_rtc->res->start,
 
277
                           resource_size(vt8500_rtc->res));
 
278
err_free:
 
279
        kfree(vt8500_rtc);
 
280
        return ret;
 
281
}
 
282
 
 
283
static int __devexit vt8500_rtc_remove(struct platform_device *pdev)
 
284
{
 
285
        struct vt8500_rtc *vt8500_rtc = platform_get_drvdata(pdev);
 
286
 
 
287
        free_irq(vt8500_rtc->irq_alarm, vt8500_rtc);
 
288
 
 
289
        rtc_device_unregister(vt8500_rtc->rtc);
 
290
 
 
291
        /* Disable alarm matching */
 
292
        writel(0, vt8500_rtc->regbase + VT8500_RTC_IS);
 
293
        iounmap(vt8500_rtc->regbase);
 
294
        release_mem_region(vt8500_rtc->res->start,
 
295
                           resource_size(vt8500_rtc->res));
 
296
 
 
297
        kfree(vt8500_rtc);
 
298
        platform_set_drvdata(pdev, NULL);
 
299
 
 
300
        return 0;
 
301
}
 
302
 
 
303
static struct platform_driver vt8500_rtc_driver = {
 
304
        .probe          = vt8500_rtc_probe,
 
305
        .remove         = __devexit_p(vt8500_rtc_remove),
 
306
        .driver         = {
 
307
                .name   = "vt8500-rtc",
 
308
                .owner  = THIS_MODULE,
 
309
        },
 
310
};
 
311
 
 
312
static int __init vt8500_rtc_init(void)
 
313
{
 
314
        return platform_driver_register(&vt8500_rtc_driver);
 
315
}
 
316
module_init(vt8500_rtc_init);
 
317
 
 
318
static void __exit vt8500_rtc_exit(void)
 
319
{
 
320
        platform_driver_unregister(&vt8500_rtc_driver);
 
321
}
 
322
module_exit(vt8500_rtc_exit);
 
323
 
 
324
MODULE_AUTHOR("Alexey Charkov <alchark@gmail.com>");
 
325
MODULE_DESCRIPTION("VIA VT8500 SoC Realtime Clock Driver (RTC)");
 
326
MODULE_LICENSE("GPL");
 
327
MODULE_ALIAS("platform:vt8500-rtc");