1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * MOXA ART RTC driver.
4  *
5  * Copyright (C) 2013 Jonas Jensen
6  *
7  * Jonas Jensen <jonas.jensen@gmail.com>
8  *
9  * Based on code from
10  * Moxa Technology Co., Ltd. <www.moxa.com>
11  */
12 
13 #include <linux/init.h>
14 #include <linux/kernel.h>
15 #include <linux/delay.h>
16 #include <linux/rtc.h>
17 #include <linux/platform_device.h>
18 #include <linux/module.h>
19 #include <linux/gpio.h>
20 #include <linux/of_gpio.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 
55 struct moxart_rtc {
56 	struct rtc_device *rtc;
57 	spinlock_t rtc_lock;
58 	int gpio_data, gpio_sclk, gpio_reset;
59 };
60 
61 static int day_of_year[12] =	{ 0, 31, 59, 90, 120, 151, 181,
62 				  212, 243, 273, 304, 334 };
63 
moxart_rtc_write_byte(struct device * dev,u8 data)64 static void moxart_rtc_write_byte(struct device *dev, u8 data)
65 {
66 	struct moxart_rtc *moxart_rtc = dev_get_drvdata(dev);
67 	int i;
68 
69 	for (i = 0; i < 8; i++, data >>= 1) {
70 		gpio_set_value(moxart_rtc->gpio_sclk, 0);
71 		gpio_set_value(moxart_rtc->gpio_data, ((data & 1) == 1));
72 		udelay(GPIO_RTC_DELAY_TIME);
73 		gpio_set_value(moxart_rtc->gpio_sclk, 1);
74 		udelay(GPIO_RTC_DELAY_TIME);
75 	}
76 }
77 
moxart_rtc_read_byte(struct device * dev)78 static u8 moxart_rtc_read_byte(struct device *dev)
79 {
80 	struct moxart_rtc *moxart_rtc = dev_get_drvdata(dev);
81 	int i;
82 	u8 data = 0;
83 
84 	for (i = 0; i < 8; i++) {
85 		gpio_set_value(moxart_rtc->gpio_sclk, 0);
86 		udelay(GPIO_RTC_DELAY_TIME);
87 		gpio_set_value(moxart_rtc->gpio_sclk, 1);
88 		udelay(GPIO_RTC_DELAY_TIME);
89 		if (gpio_get_value(moxart_rtc->gpio_data))
90 			data |= (1 << i);
91 		udelay(GPIO_RTC_DELAY_TIME);
92 	}
93 	return data;
94 }
95 
moxart_rtc_read_register(struct device * dev,u8 cmd)96 static u8 moxart_rtc_read_register(struct device *dev, u8 cmd)
97 {
98 	struct moxart_rtc *moxart_rtc = dev_get_drvdata(dev);
99 	u8 data;
100 	unsigned long flags;
101 
102 	local_irq_save(flags);
103 
104 	gpio_direction_output(moxart_rtc->gpio_data, 0);
105 	gpio_set_value(moxart_rtc->gpio_reset, 1);
106 	udelay(GPIO_RTC_DELAY_TIME);
107 	moxart_rtc_write_byte(dev, cmd);
108 	gpio_direction_input(moxart_rtc->gpio_data);
109 	udelay(GPIO_RTC_DELAY_TIME);
110 	data = moxart_rtc_read_byte(dev);
111 	gpio_set_value(moxart_rtc->gpio_sclk, 0);
112 	gpio_set_value(moxart_rtc->gpio_reset, 0);
113 	udelay(GPIO_RTC_DELAY_TIME);
114 
115 	local_irq_restore(flags);
116 
117 	return data;
118 }
119 
moxart_rtc_write_register(struct device * dev,u8 cmd,u8 data)120 static void moxart_rtc_write_register(struct device *dev, u8 cmd, u8 data)
121 {
122 	struct moxart_rtc *moxart_rtc = dev_get_drvdata(dev);
123 	unsigned long flags;
124 
125 	local_irq_save(flags);
126 
127 	gpio_direction_output(moxart_rtc->gpio_data, 0);
128 	gpio_set_value(moxart_rtc->gpio_reset, 1);
129 	udelay(GPIO_RTC_DELAY_TIME);
130 	moxart_rtc_write_byte(dev, cmd);
131 	moxart_rtc_write_byte(dev, data);
132 	gpio_set_value(moxart_rtc->gpio_sclk, 0);
133 	gpio_set_value(moxart_rtc->gpio_reset, 0);
134 	udelay(GPIO_RTC_DELAY_TIME);
135 
136 	local_irq_restore(flags);
137 }
138 
moxart_rtc_set_time(struct device * dev,struct rtc_time * tm)139 static int moxart_rtc_set_time(struct device *dev, struct rtc_time *tm)
140 {
141 	struct moxart_rtc *moxart_rtc = dev_get_drvdata(dev);
142 
143 	spin_lock_irq(&moxart_rtc->rtc_lock);
144 
145 	moxart_rtc_write_register(dev, GPIO_RTC_PROTECT_W, 0);
146 	moxart_rtc_write_register(dev, GPIO_RTC_YEAR_W,
147 				  (((tm->tm_year - 100) / 10) << 4) |
148 				  ((tm->tm_year - 100) % 10));
149 
150 	moxart_rtc_write_register(dev, GPIO_RTC_MONTH_W,
151 				  (((tm->tm_mon + 1) / 10) << 4) |
152 				  ((tm->tm_mon + 1) % 10));
153 
154 	moxart_rtc_write_register(dev, GPIO_RTC_DATE_W,
155 				  ((tm->tm_mday / 10) << 4) |
156 				  (tm->tm_mday % 10));
157 
158 	moxart_rtc_write_register(dev, GPIO_RTC_HOURS_W,
159 				  ((tm->tm_hour / 10) << 4) |
160 				  (tm->tm_hour % 10));
161 
162 	moxart_rtc_write_register(dev, GPIO_RTC_MINUTES_W,
163 				  ((tm->tm_min / 10) << 4) |
164 				  (tm->tm_min % 10));
165 
166 	moxart_rtc_write_register(dev, GPIO_RTC_SECONDS_W,
167 				  ((tm->tm_sec / 10) << 4) |
168 				  (tm->tm_sec % 10));
169 
170 	moxart_rtc_write_register(dev, GPIO_RTC_PROTECT_W, 0x80);
171 
172 	spin_unlock_irq(&moxart_rtc->rtc_lock);
173 
174 	dev_dbg(dev, "%s: success tm_year=%d tm_mon=%d\n"
175 		"tm_mday=%d tm_hour=%d tm_min=%d tm_sec=%d\n",
176 		__func__, tm->tm_year, tm->tm_mon, tm->tm_mday,
177 		tm->tm_hour, tm->tm_min, tm->tm_sec);
178 
179 	return 0;
180 }
181 
moxart_rtc_read_time(struct device * dev,struct rtc_time * tm)182 static int moxart_rtc_read_time(struct device *dev, struct rtc_time *tm)
183 {
184 	struct moxart_rtc *moxart_rtc = dev_get_drvdata(dev);
185 	unsigned char v;
186 
187 	spin_lock_irq(&moxart_rtc->rtc_lock);
188 
189 	v = moxart_rtc_read_register(dev, GPIO_RTC_SECONDS_R);
190 	tm->tm_sec = (((v & 0x70) >> 4) * 10) + (v & 0x0F);
191 
192 	v = moxart_rtc_read_register(dev, GPIO_RTC_MINUTES_R);
193 	tm->tm_min = (((v & 0x70) >> 4) * 10) + (v & 0x0F);
194 
195 	v = moxart_rtc_read_register(dev, GPIO_RTC_HOURS_R);
196 	if (v & 0x80) { /* 12-hour mode */
197 		tm->tm_hour = (((v & 0x10) >> 4) * 10) + (v & 0x0F);
198 		if (v & 0x20) { /* PM mode */
199 			tm->tm_hour += 12;
200 			if (tm->tm_hour >= 24)
201 				tm->tm_hour = 0;
202 		}
203 	} else { /* 24-hour mode */
204 		tm->tm_hour = (((v & 0x30) >> 4) * 10) + (v & 0x0F);
205 	}
206 
207 	v = moxart_rtc_read_register(dev, GPIO_RTC_DATE_R);
208 	tm->tm_mday = (((v & 0x30) >> 4) * 10) + (v & 0x0F);
209 
210 	v = moxart_rtc_read_register(dev, GPIO_RTC_MONTH_R);
211 	tm->tm_mon = (((v & 0x10) >> 4) * 10) + (v & 0x0F);
212 	tm->tm_mon--;
213 
214 	v = moxart_rtc_read_register(dev, GPIO_RTC_YEAR_R);
215 	tm->tm_year = (((v & 0xF0) >> 4) * 10) + (v & 0x0F);
216 	tm->tm_year += 100;
217 	if (tm->tm_year <= 69)
218 		tm->tm_year += 100;
219 
220 	v = moxart_rtc_read_register(dev, GPIO_RTC_DAY_R);
221 	tm->tm_wday = (v & 0x0f) - 1;
222 	tm->tm_yday = day_of_year[tm->tm_mon];
223 	tm->tm_yday += (tm->tm_mday - 1);
224 	if (tm->tm_mon >= 2) {
225 		if (!(tm->tm_year % 4) && (tm->tm_year % 100))
226 			tm->tm_yday++;
227 	}
228 
229 	tm->tm_isdst = 0;
230 
231 	spin_unlock_irq(&moxart_rtc->rtc_lock);
232 
233 	return 0;
234 }
235 
236 static const struct rtc_class_ops moxart_rtc_ops = {
237 	.read_time	= moxart_rtc_read_time,
238 	.set_time	= moxart_rtc_set_time,
239 };
240 
moxart_rtc_probe(struct platform_device * pdev)241 static int moxart_rtc_probe(struct platform_device *pdev)
242 {
243 	struct moxart_rtc *moxart_rtc;
244 	int ret = 0;
245 
246 	moxart_rtc = devm_kzalloc(&pdev->dev, sizeof(*moxart_rtc), GFP_KERNEL);
247 	if (!moxart_rtc)
248 		return -ENOMEM;
249 
250 	moxart_rtc->gpio_data = of_get_named_gpio(pdev->dev.of_node,
251 						  "gpio-rtc-data", 0);
252 	if (!gpio_is_valid(moxart_rtc->gpio_data)) {
253 		dev_err(&pdev->dev, "invalid gpio (data): %d\n",
254 			moxart_rtc->gpio_data);
255 		return moxart_rtc->gpio_data;
256 	}
257 
258 	moxart_rtc->gpio_sclk = of_get_named_gpio(pdev->dev.of_node,
259 						  "gpio-rtc-sclk", 0);
260 	if (!gpio_is_valid(moxart_rtc->gpio_sclk)) {
261 		dev_err(&pdev->dev, "invalid gpio (sclk): %d\n",
262 			moxart_rtc->gpio_sclk);
263 		return moxart_rtc->gpio_sclk;
264 	}
265 
266 	moxart_rtc->gpio_reset = of_get_named_gpio(pdev->dev.of_node,
267 						   "gpio-rtc-reset", 0);
268 	if (!gpio_is_valid(moxart_rtc->gpio_reset)) {
269 		dev_err(&pdev->dev, "invalid gpio (reset): %d\n",
270 			moxart_rtc->gpio_reset);
271 		return moxart_rtc->gpio_reset;
272 	}
273 
274 	spin_lock_init(&moxart_rtc->rtc_lock);
275 	platform_set_drvdata(pdev, moxart_rtc);
276 
277 	ret = devm_gpio_request(&pdev->dev, moxart_rtc->gpio_data, "rtc_data");
278 	if (ret) {
279 		dev_err(&pdev->dev, "can't get rtc_data gpio\n");
280 		return ret;
281 	}
282 
283 	ret = devm_gpio_request_one(&pdev->dev, moxart_rtc->gpio_sclk,
284 				    GPIOF_DIR_OUT, "rtc_sclk");
285 	if (ret) {
286 		dev_err(&pdev->dev, "can't get rtc_sclk gpio\n");
287 		return ret;
288 	}
289 
290 	ret = devm_gpio_request_one(&pdev->dev, moxart_rtc->gpio_reset,
291 				    GPIOF_DIR_OUT, "rtc_reset");
292 	if (ret) {
293 		dev_err(&pdev->dev, "can't get rtc_reset gpio\n");
294 		return ret;
295 	}
296 
297 	moxart_rtc->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
298 						   &moxart_rtc_ops,
299 						   THIS_MODULE);
300 	if (IS_ERR(moxart_rtc->rtc)) {
301 		dev_err(&pdev->dev, "devm_rtc_device_register failed\n");
302 		return PTR_ERR(moxart_rtc->rtc);
303 	}
304 
305 	return 0;
306 }
307 
308 static const struct of_device_id moxart_rtc_match[] = {
309 	{ .compatible = "moxa,moxart-rtc" },
310 	{ },
311 };
312 MODULE_DEVICE_TABLE(of, moxart_rtc_match);
313 
314 static struct platform_driver moxart_rtc_driver = {
315 	.probe	= moxart_rtc_probe,
316 	.driver	= {
317 		.name		= "moxart-rtc",
318 		.of_match_table	= moxart_rtc_match,
319 	},
320 };
321 module_platform_driver(moxart_rtc_driver);
322 
323 MODULE_DESCRIPTION("MOXART RTC driver");
324 MODULE_LICENSE("GPL");
325 MODULE_AUTHOR("Jonas Jensen <jonas.jensen@gmail.com>");
326