tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1/*
2 * A driver for the RTC embedded in the Cirrus Logic EP93XX processors
3 * Copyright (c) 2006 Tower Technologies
4 *
5 * Author: Alessandro Zummo <a.zummo@towertech.it>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
10 */
11
12#include <linux/module.h>
13#include <linux/rtc.h>
14#include <linux/platform_device.h>
15#include <linux/io.h>
16
17#define EP93XX_RTC_DATA 0x000
18#define EP93XX_RTC_MATCH 0x004
19#define EP93XX_RTC_STATUS 0x008
20#define EP93XX_RTC_STATUS_INTR (1<<0)
21#define EP93XX_RTC_LOAD 0x00C
22#define EP93XX_RTC_CONTROL 0x010
23#define EP93XX_RTC_CONTROL_MIE (1<<0)
24#define EP93XX_RTC_SWCOMP 0x108
25#define EP93XX_RTC_SWCOMP_DEL_MASK 0x001f0000
26#define EP93XX_RTC_SWCOMP_DEL_SHIFT 16
27#define EP93XX_RTC_SWCOMP_INT_MASK 0x0000ffff
28#define EP93XX_RTC_SWCOMP_INT_SHIFT 0
29
30#define DRV_VERSION "0.3"
31
32/*
33 * struct device dev.platform_data is used to store our private data
34 * because struct rtc_device does not have a variable to hold it.
35 */
36struct ep93xx_rtc {
37 void __iomem *mmio_base;
38};
39
40static int ep93xx_rtc_get_swcomp(struct device *dev, unsigned short *preload,
41 unsigned short *delete)
42{
43 struct ep93xx_rtc *ep93xx_rtc = dev->platform_data;
44 unsigned long comp;
45
46 comp = __raw_readl(ep93xx_rtc->mmio_base + EP93XX_RTC_SWCOMP);
47
48 if (preload)
49 *preload = (comp & EP93XX_RTC_SWCOMP_INT_MASK)
50 >> EP93XX_RTC_SWCOMP_INT_SHIFT;
51
52 if (delete)
53 *delete = (comp & EP93XX_RTC_SWCOMP_DEL_MASK)
54 >> EP93XX_RTC_SWCOMP_DEL_SHIFT;
55
56 return 0;
57}
58
59static int ep93xx_rtc_read_time(struct device *dev, struct rtc_time *tm)
60{
61 struct ep93xx_rtc *ep93xx_rtc = dev->platform_data;
62 unsigned long time;
63
64 time = __raw_readl(ep93xx_rtc->mmio_base + EP93XX_RTC_DATA);
65
66 rtc_time_to_tm(time, tm);
67 return 0;
68}
69
70static int ep93xx_rtc_set_mmss(struct device *dev, unsigned long secs)
71{
72 struct ep93xx_rtc *ep93xx_rtc = dev->platform_data;
73
74 __raw_writel(secs + 1, ep93xx_rtc->mmio_base + EP93XX_RTC_LOAD);
75 return 0;
76}
77
78static int ep93xx_rtc_proc(struct device *dev, struct seq_file *seq)
79{
80 unsigned short preload, delete;
81
82 ep93xx_rtc_get_swcomp(dev, &preload, &delete);
83
84 seq_printf(seq, "preload\t\t: %d\n", preload);
85 seq_printf(seq, "delete\t\t: %d\n", delete);
86
87 return 0;
88}
89
90static const struct rtc_class_ops ep93xx_rtc_ops = {
91 .read_time = ep93xx_rtc_read_time,
92 .set_mmss = ep93xx_rtc_set_mmss,
93 .proc = ep93xx_rtc_proc,
94};
95
96static ssize_t ep93xx_rtc_show_comp_preload(struct device *dev,
97 struct device_attribute *attr, char *buf)
98{
99 unsigned short preload;
100
101 ep93xx_rtc_get_swcomp(dev, &preload, NULL);
102
103 return sprintf(buf, "%d\n", preload);
104}
105static DEVICE_ATTR(comp_preload, S_IRUGO, ep93xx_rtc_show_comp_preload, NULL);
106
107static ssize_t ep93xx_rtc_show_comp_delete(struct device *dev,
108 struct device_attribute *attr, char *buf)
109{
110 unsigned short delete;
111
112 ep93xx_rtc_get_swcomp(dev, NULL, &delete);
113
114 return sprintf(buf, "%d\n", delete);
115}
116static DEVICE_ATTR(comp_delete, S_IRUGO, ep93xx_rtc_show_comp_delete, NULL);
117
118
119static int __init ep93xx_rtc_probe(struct platform_device *pdev)
120{
121 struct ep93xx_rtc *ep93xx_rtc;
122 struct resource *res;
123 struct rtc_device *rtc;
124 int err;
125
126 ep93xx_rtc = kzalloc(sizeof(struct ep93xx_rtc), GFP_KERNEL);
127 if (ep93xx_rtc == NULL)
128 return -ENOMEM;
129
130 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
131 if (res == NULL) {
132 err = -ENXIO;
133 goto fail_free;
134 }
135
136 res = request_mem_region(res->start, resource_size(res), pdev->name);
137 if (res == NULL) {
138 err = -EBUSY;
139 goto fail_free;
140 }
141
142 ep93xx_rtc->mmio_base = ioremap(res->start, resource_size(res));
143 if (ep93xx_rtc->mmio_base == NULL) {
144 err = -ENXIO;
145 goto fail;
146 }
147
148 pdev->dev.platform_data = ep93xx_rtc;
149
150 rtc = rtc_device_register(pdev->name,
151 &pdev->dev, &ep93xx_rtc_ops, THIS_MODULE);
152 if (IS_ERR(rtc)) {
153 err = PTR_ERR(rtc);
154 goto fail;
155 }
156
157 platform_set_drvdata(pdev, rtc);
158
159 err = device_create_file(&pdev->dev, &dev_attr_comp_preload);
160 if (err)
161 goto fail;
162 err = device_create_file(&pdev->dev, &dev_attr_comp_delete);
163 if (err) {
164 device_remove_file(&pdev->dev, &dev_attr_comp_preload);
165 goto fail;
166 }
167
168 return 0;
169
170fail:
171 if (ep93xx_rtc->mmio_base) {
172 iounmap(ep93xx_rtc->mmio_base);
173 pdev->dev.platform_data = NULL;
174 }
175 release_mem_region(res->start, resource_size(res));
176fail_free:
177 kfree(ep93xx_rtc);
178 return err;
179}
180
181static int __exit ep93xx_rtc_remove(struct platform_device *pdev)
182{
183 struct rtc_device *rtc = platform_get_drvdata(pdev);
184 struct ep93xx_rtc *ep93xx_rtc = pdev->dev.platform_data;
185 struct resource *res;
186
187 /* cleanup sysfs */
188 device_remove_file(&pdev->dev, &dev_attr_comp_delete);
189 device_remove_file(&pdev->dev, &dev_attr_comp_preload);
190
191 rtc_device_unregister(rtc);
192
193 iounmap(ep93xx_rtc->mmio_base);
194 pdev->dev.platform_data = NULL;
195
196 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
197 release_mem_region(res->start, resource_size(res));
198
199 platform_set_drvdata(pdev, NULL);
200
201 return 0;
202}
203
204/* work with hotplug and coldplug */
205MODULE_ALIAS("platform:ep93xx-rtc");
206
207static struct platform_driver ep93xx_rtc_driver = {
208 .driver = {
209 .name = "ep93xx-rtc",
210 .owner = THIS_MODULE,
211 },
212 .remove = __exit_p(ep93xx_rtc_remove),
213};
214
215static int __init ep93xx_rtc_init(void)
216{
217 return platform_driver_probe(&ep93xx_rtc_driver, ep93xx_rtc_probe);
218}
219
220static void __exit ep93xx_rtc_exit(void)
221{
222 platform_driver_unregister(&ep93xx_rtc_driver);
223}
224
225MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
226MODULE_DESCRIPTION("EP93XX RTC driver");
227MODULE_LICENSE("GPL");
228MODULE_VERSION(DRV_VERSION);
229
230module_init(ep93xx_rtc_init);
231module_exit(ep93xx_rtc_exit);