projects/linux·blob master · refs

307 lines · 8.1 KiB

1// SPDX-License-Identifier: GPL-2.0
2/*
3 * MOXA ART RTC driver.
4 *
5 * Copyright (C) 2013 Jonas Jensen
6 *
7 * Jonas Jensen <[email protected]>
8 *
9 * Based on code from
10 * Moxa Technology Co., Ltd. <www.moxa.com>
11 */
12
13#include <linux/err.h>
14#include <linux/init.h>
15#include <linux/kernel.h>
16#include <linux/delay.h>
17#include <linux/rtc.h>
18#include <linux/platform_device.h>
19#include <linux/module.h>
20#include <linux/gpio/consumer.h>
21
22#define GPIO_RTC_RESERVED 0x0C
23#define GPIO_RTC_DATA_SET 0x10
24#define GPIO_RTC_DATA_CLEAR 0x14
25#define GPIO_RTC_PIN_PULL_ENABLE 0x18
26#define GPIO_RTC_PIN_PULL_TYPE 0x1C
27#define GPIO_RTC_INT_ENABLE 0x20
28#define GPIO_RTC_INT_RAW_STATE 0x24
29#define GPIO_RTC_INT_MASKED_STATE 0x28
30#define GPIO_RTC_INT_MASK 0x2C
31#define GPIO_RTC_INT_CLEAR 0x30
32#define GPIO_RTC_INT_TRIGGER 0x34
33#define GPIO_RTC_INT_BOTH 0x38
34#define GPIO_RTC_INT_RISE_NEG 0x3C
35#define GPIO_RTC_BOUNCE_ENABLE 0x40
36#define GPIO_RTC_BOUNCE_PRE_SCALE 0x44
37#define GPIO_RTC_PROTECT_W 0x8E
38#define GPIO_RTC_PROTECT_R 0x8F
39#define GPIO_RTC_YEAR_W 0x8C
40#define GPIO_RTC_YEAR_R 0x8D
41#define GPIO_RTC_DAY_W 0x8A
42#define GPIO_RTC_DAY_R 0x8B
43#define GPIO_RTC_MONTH_W 0x88
44#define GPIO_RTC_MONTH_R 0x89
45#define GPIO_RTC_DATE_W 0x86
46#define GPIO_RTC_DATE_R 0x87
47#define GPIO_RTC_HOURS_W 0x84
48#define GPIO_RTC_HOURS_R 0x85
49#define GPIO_RTC_MINUTES_W 0x82
50#define GPIO_RTC_MINUTES_R 0x83
51#define GPIO_RTC_SECONDS_W 0x80
52#define GPIO_RTC_SECONDS_R 0x81
53#define GPIO_RTC_DELAY_TIME 8
54
55struct moxart_rtc {
56 struct rtc_device *rtc;
57 spinlock_t rtc_lock;
58 struct gpio_desc *gpio_data;
59 struct gpio_desc *gpio_sclk;
60 struct gpio_desc *gpio_reset;
61};
62
63static int day_of_year[12] = { 0, 31, 59, 90, 120, 151, 181,
64 212, 243, 273, 304, 334 };
65
66static void moxart_rtc_write_byte(struct device *dev, u8 data)
67{
68 struct moxart_rtc *moxart_rtc = dev_get_drvdata(dev);
69 int i;
70
71 for (i = 0; i < 8; i++, data >>= 1) {
72 gpiod_set_value(moxart_rtc->gpio_sclk, 0);
73 gpiod_set_value(moxart_rtc->gpio_data, ((data & 1) == 1));
74 udelay(GPIO_RTC_DELAY_TIME);
75 gpiod_set_value(moxart_rtc->gpio_sclk, 1);
76 udelay(GPIO_RTC_DELAY_TIME);
77 }
78}
79
80static u8 moxart_rtc_read_byte(struct device *dev)
81{
82 struct moxart_rtc *moxart_rtc = dev_get_drvdata(dev);
83 int i;
84 u8 data = 0;
85
86 for (i = 0; i < 8; i++) {
87 gpiod_set_value(moxart_rtc->gpio_sclk, 0);
88 udelay(GPIO_RTC_DELAY_TIME);
89 gpiod_set_value(moxart_rtc->gpio_sclk, 1);
90 udelay(GPIO_RTC_DELAY_TIME);
91 if (gpiod_get_value(moxart_rtc->gpio_data))
92 data |= (1 << i);
93 udelay(GPIO_RTC_DELAY_TIME);
94 }
95 return data;
96}
97
98static u8 moxart_rtc_read_register(struct device *dev, u8 cmd)
99{
100 struct moxart_rtc *moxart_rtc = dev_get_drvdata(dev);
101 u8 data;
102 unsigned long flags;
103
104 local_irq_save(flags);
105
106 gpiod_direction_output(moxart_rtc->gpio_data, 0);
107 gpiod_set_value(moxart_rtc->gpio_reset, 1);
108 udelay(GPIO_RTC_DELAY_TIME);
109 moxart_rtc_write_byte(dev, cmd);
110 gpiod_direction_input(moxart_rtc->gpio_data);
111 udelay(GPIO_RTC_DELAY_TIME);
112 data = moxart_rtc_read_byte(dev);
113 gpiod_set_value(moxart_rtc->gpio_sclk, 0);
114 gpiod_set_value(moxart_rtc->gpio_reset, 0);
115 udelay(GPIO_RTC_DELAY_TIME);
116
117 local_irq_restore(flags);
118
119 return data;
120}
121
122static void moxart_rtc_write_register(struct device *dev, u8 cmd, u8 data)
123{
124 struct moxart_rtc *moxart_rtc = dev_get_drvdata(dev);
125 unsigned long flags;
126
127 local_irq_save(flags);
128
129 gpiod_direction_output(moxart_rtc->gpio_data, 0);
130 gpiod_set_value(moxart_rtc->gpio_reset, 1);
131 udelay(GPIO_RTC_DELAY_TIME);
132 moxart_rtc_write_byte(dev, cmd);
133 moxart_rtc_write_byte(dev, data);
134 gpiod_set_value(moxart_rtc->gpio_sclk, 0);
135 gpiod_set_value(moxart_rtc->gpio_reset, 0);
136 udelay(GPIO_RTC_DELAY_TIME);
137
138 local_irq_restore(flags);
139}
140
141static int moxart_rtc_set_time(struct device *dev, struct rtc_time *tm)
142{
143 struct moxart_rtc *moxart_rtc = dev_get_drvdata(dev);
144
145 spin_lock_irq(&moxart_rtc->rtc_lock);
146
147 moxart_rtc_write_register(dev, GPIO_RTC_PROTECT_W, 0);
148 moxart_rtc_write_register(dev, GPIO_RTC_YEAR_W,
149 (((tm->tm_year - 100) / 10) << 4) |
150 ((tm->tm_year - 100) % 10));
151
152 moxart_rtc_write_register(dev, GPIO_RTC_MONTH_W,
153 (((tm->tm_mon + 1) / 10) << 4) |
154 ((tm->tm_mon + 1) % 10));
155
156 moxart_rtc_write_register(dev, GPIO_RTC_DATE_W,
157 ((tm->tm_mday / 10) << 4) |
158 (tm->tm_mday % 10));
159
160 moxart_rtc_write_register(dev, GPIO_RTC_HOURS_W,
161 ((tm->tm_hour / 10) << 4) |
162 (tm->tm_hour % 10));
163
164 moxart_rtc_write_register(dev, GPIO_RTC_MINUTES_W,
165 ((tm->tm_min / 10) << 4) |
166 (tm->tm_min % 10));
167
168 moxart_rtc_write_register(dev, GPIO_RTC_SECONDS_W,
169 ((tm->tm_sec / 10) << 4) |
170 (tm->tm_sec % 10));
171
172 moxart_rtc_write_register(dev, GPIO_RTC_PROTECT_W, 0x80);
173
174 spin_unlock_irq(&moxart_rtc->rtc_lock);
175
176 dev_dbg(dev, "%s: success tm_year=%d tm_mon=%d\n"
177 "tm_mday=%d tm_hour=%d tm_min=%d tm_sec=%d\n",
178 __func__, tm->tm_year, tm->tm_mon, tm->tm_mday,
179 tm->tm_hour, tm->tm_min, tm->tm_sec);
180
181 return 0;
182}
183
184static int moxart_rtc_read_time(struct device *dev, struct rtc_time *tm)
185{
186 struct moxart_rtc *moxart_rtc = dev_get_drvdata(dev);
187 unsigned char v;
188
189 spin_lock_irq(&moxart_rtc->rtc_lock);
190
191 v = moxart_rtc_read_register(dev, GPIO_RTC_SECONDS_R);
192 tm->tm_sec = (((v & 0x70) >> 4) * 10) + (v & 0x0F);
193
194 v = moxart_rtc_read_register(dev, GPIO_RTC_MINUTES_R);
195 tm->tm_min = (((v & 0x70) >> 4) * 10) + (v & 0x0F);
196
197 v = moxart_rtc_read_register(dev, GPIO_RTC_HOURS_R);
198 if (v & 0x80) { /* 12-hour mode */
199 tm->tm_hour = (((v & 0x10) >> 4) * 10) + (v & 0x0F);
200 if (v & 0x20) { /* PM mode */
201 tm->tm_hour += 12;
202 if (tm->tm_hour >= 24)
203 tm->tm_hour = 0;
204 }
205 } else { /* 24-hour mode */
206 tm->tm_hour = (((v & 0x30) >> 4) * 10) + (v & 0x0F);
207 }
208
209 v = moxart_rtc_read_register(dev, GPIO_RTC_DATE_R);
210 tm->tm_mday = (((v & 0x30) >> 4) * 10) + (v & 0x0F);
211
212 v = moxart_rtc_read_register(dev, GPIO_RTC_MONTH_R);
213 tm->tm_mon = (((v & 0x10) >> 4) * 10) + (v & 0x0F);
214 tm->tm_mon--;
215
216 v = moxart_rtc_read_register(dev, GPIO_RTC_YEAR_R);
217 tm->tm_year = (((v & 0xF0) >> 4) * 10) + (v & 0x0F);
218 tm->tm_year += 100;
219 if (tm->tm_year <= 69)
220 tm->tm_year += 100;
221
222 v = moxart_rtc_read_register(dev, GPIO_RTC_DAY_R);
223 tm->tm_wday = (v & 0x0f) - 1;
224 tm->tm_yday = day_of_year[tm->tm_mon];
225 tm->tm_yday += (tm->tm_mday - 1);
226 if (tm->tm_mon >= 2) {
227 if (!(tm->tm_year % 4) && (tm->tm_year % 100))
228 tm->tm_yday++;
229 }
230
231 tm->tm_isdst = 0;
232
233 spin_unlock_irq(&moxart_rtc->rtc_lock);
234
235 return 0;
236}
237
238static const struct rtc_class_ops moxart_rtc_ops = {
239 .read_time = moxart_rtc_read_time,
240 .set_time = moxart_rtc_set_time,
241};
242
243static int moxart_rtc_probe(struct platform_device *pdev)
244{
245 struct moxart_rtc *moxart_rtc;
246 int ret = 0;
247
248 moxart_rtc = devm_kzalloc(&pdev->dev, sizeof(*moxart_rtc), GFP_KERNEL);
249 if (!moxart_rtc)
250 return -ENOMEM;
251
252 moxart_rtc->gpio_data = devm_gpiod_get(&pdev->dev, "rtc-data",
253 GPIOD_IN);
254 ret = PTR_ERR_OR_ZERO(moxart_rtc->gpio_data);
255 if (ret) {
256 dev_err(&pdev->dev, "can't get rtc data gpio: %d\n", ret);
257 return ret;
258 }
259
260 moxart_rtc->gpio_sclk = devm_gpiod_get(&pdev->dev, "rtc-sclk",
261 GPIOD_ASIS);
262 ret = PTR_ERR_OR_ZERO(moxart_rtc->gpio_sclk);
263 if (ret) {
264 dev_err(&pdev->dev, "can't get rtc sclk gpio: %d\n", ret);
265 return ret;
266 }
267
268 moxart_rtc->gpio_reset = devm_gpiod_get(&pdev->dev, "rtc-reset",
269 GPIOD_ASIS);
270 ret = PTR_ERR_OR_ZERO(moxart_rtc->gpio_reset);
271 if (ret) {
272 dev_err(&pdev->dev, "can't get rtc reset gpio: %d\n", ret);
273 return ret;
274 }
275
276 spin_lock_init(&moxart_rtc->rtc_lock);
277 platform_set_drvdata(pdev, moxart_rtc);
278
279 moxart_rtc->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
280 &moxart_rtc_ops,
281 THIS_MODULE);
282 if (IS_ERR(moxart_rtc->rtc)) {
283 dev_err(&pdev->dev, "devm_rtc_device_register failed\n");
284 return PTR_ERR(moxart_rtc->rtc);
285 }
286
287 return 0;
288}
289
290static const struct of_device_id moxart_rtc_match[] = {
291 { .compatible = "moxa,moxart-rtc" },
292 { },
293};
294MODULE_DEVICE_TABLE(of, moxart_rtc_match);
295
296static struct platform_driver moxart_rtc_driver = {
297 .probe = moxart_rtc_probe,
298 .driver = {
299 .name = "moxart-rtc",
300 .of_match_table = moxart_rtc_match,
301 },
302};
303module_platform_driver(moxart_rtc_driver);
304
305MODULE_DESCRIPTION("MOXART RTC driver");
306MODULE_LICENSE("GPL");
307MODULE_AUTHOR("Jonas Jensen <[email protected]>");