?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
drm/msm/dpu: remove RM topology definition
[linux/fpc-iii.git] / drivers / rtc / rtc-r7301.c
blob1943c815115266ff336690abdb0ac6331cb690fd
1 /*
2 * EPSON TOYOCOM RTC-7301SF/DG Driver
3 *
4 * Copyright (c) 2016 Akinobu Mita <akinobu.mita@gmail.com>
5 *
6 * Based on rtc-rp5c01.c
7 *
8 * Datasheet: http://www5.epsondevice.com/en/products/parallel/rtc7301sf.html
9 */
10
11 #include <linux/io.h>
12 #include <linux/kernel.h>
13 #include <linux/module.h>
14 #include <linux/mod_devicetable.h>
15 #include <linux/delay.h>
16 #include <linux/regmap.h>
17 #include <linux/platform_device.h>
18 #include <linux/rtc.h>
19
20 #define DRV_NAME "rtc-r7301"
21
22 #define RTC7301_1_SEC 0x0 /* Bank 0 and Band 1 */
23 #define RTC7301_10_SEC 0x1 /* Bank 0 and Band 1 */
24 #define RTC7301_AE BIT(3)
25 #define RTC7301_1_MIN 0x2 /* Bank 0 and Band 1 */
26 #define RTC7301_10_MIN 0x3 /* Bank 0 and Band 1 */
27 #define RTC7301_1_HOUR 0x4 /* Bank 0 and Band 1 */
28 #define RTC7301_10_HOUR 0x5 /* Bank 0 and Band 1 */
29 #define RTC7301_DAY_OF_WEEK 0x6 /* Bank 0 and Band 1 */
30 #define RTC7301_1_DAY 0x7 /* Bank 0 and Band 1 */
31 #define RTC7301_10_DAY 0x8 /* Bank 0 and Band 1 */
32 #define RTC7301_1_MONTH 0x9 /* Bank 0 */
33 #define RTC7301_10_MONTH 0xa /* Bank 0 */
34 #define RTC7301_1_YEAR 0xb /* Bank 0 */
35 #define RTC7301_10_YEAR 0xc /* Bank 0 */
36 #define RTC7301_100_YEAR 0xd /* Bank 0 */
37 #define RTC7301_1000_YEAR 0xe /* Bank 0 */
38 #define RTC7301_ALARM_CONTROL 0xe /* Bank 1 */
39 #define RTC7301_ALARM_CONTROL_AIE BIT(0)
40 #define RTC7301_ALARM_CONTROL_AF BIT(1)
41 #define RTC7301_TIMER_CONTROL 0xe /* Bank 2 */
42 #define RTC7301_TIMER_CONTROL_TIE BIT(0)
43 #define RTC7301_TIMER_CONTROL_TF BIT(1)
44 #define RTC7301_CONTROL 0xf /* All banks */
45 #define RTC7301_CONTROL_BUSY BIT(0)
46 #define RTC7301_CONTROL_STOP BIT(1)
47 #define RTC7301_CONTROL_BANK_SEL_0 BIT(2)
48 #define RTC7301_CONTROL_BANK_SEL_1 BIT(3)
49
50 struct rtc7301_priv {
51 struct regmap *regmap;
52 int irq;
53 spinlock_t lock;
54 u8 bank;
55 };
56
57 static const struct regmap_config rtc7301_regmap_config = {
58 .reg_bits = 32,
59 .val_bits = 8,
60 .reg_stride = 4,
61 };
62
63 static u8 rtc7301_read(struct rtc7301_priv *priv, unsigned int reg)
64 {
65 int reg_stride = regmap_get_reg_stride(priv->regmap);
66 unsigned int val;
67
68 regmap_read(priv->regmap, reg_stride * reg, &val);
69
70 return val & 0xf;
71 }
72
73 static void rtc7301_write(struct rtc7301_priv *priv, u8 val, unsigned int reg)
74 {
75 int reg_stride = regmap_get_reg_stride(priv->regmap);
76
77 regmap_write(priv->regmap, reg_stride * reg, val);
78 }
79
80 static void rtc7301_update_bits(struct rtc7301_priv *priv, unsigned int reg,
81 u8 mask, u8 val)
82 {
83 int reg_stride = regmap_get_reg_stride(priv->regmap);
84
85 regmap_update_bits(priv->regmap, reg_stride * reg, mask, val);
86 }
87
88 static int rtc7301_wait_while_busy(struct rtc7301_priv *priv)
89 {
90 int retries = 100;
91
92 while (retries-- > 0) {
93 u8 val;
94
95 val = rtc7301_read(priv, RTC7301_CONTROL);
96 if (!(val & RTC7301_CONTROL_BUSY))
97 return 0;
98
99 udelay(300);
100 }
101
102 return -ETIMEDOUT;
103 }
104
105 static void rtc7301_stop(struct rtc7301_priv *priv)
106 {
107 rtc7301_update_bits(priv, RTC7301_CONTROL, RTC7301_CONTROL_STOP,
108 RTC7301_CONTROL_STOP);
109 }
110
111 static void rtc7301_start(struct rtc7301_priv *priv)
112 {
113 rtc7301_update_bits(priv, RTC7301_CONTROL, RTC7301_CONTROL_STOP, 0);
114 }
115
116 static void rtc7301_select_bank(struct rtc7301_priv *priv, u8 bank)
117 {
118 u8 val = 0;
119
120 if (bank == priv->bank)
121 return;
122
123 if (bank & BIT(0))
124 val |= RTC7301_CONTROL_BANK_SEL_0;
125 if (bank & BIT(1))
126 val |= RTC7301_CONTROL_BANK_SEL_1;
127
128 rtc7301_update_bits(priv, RTC7301_CONTROL,
129 RTC7301_CONTROL_BANK_SEL_0 |
130 RTC7301_CONTROL_BANK_SEL_1, val);
131
132 priv->bank = bank;
133 }
134
135 static void rtc7301_get_time(struct rtc7301_priv *priv, struct rtc_time *tm,
136 bool alarm)
137 {
138 int year;
139
140 tm->tm_sec = rtc7301_read(priv, RTC7301_1_SEC);
141 tm->tm_sec += (rtc7301_read(priv, RTC7301_10_SEC) & ~RTC7301_AE) * 10;
142 tm->tm_min = rtc7301_read(priv, RTC7301_1_MIN);
143 tm->tm_min += (rtc7301_read(priv, RTC7301_10_MIN) & ~RTC7301_AE) * 10;
144 tm->tm_hour = rtc7301_read(priv, RTC7301_1_HOUR);
145 tm->tm_hour += (rtc7301_read(priv, RTC7301_10_HOUR) & ~RTC7301_AE) * 10;
146 tm->tm_mday = rtc7301_read(priv, RTC7301_1_DAY);
147 tm->tm_mday += (rtc7301_read(priv, RTC7301_10_DAY) & ~RTC7301_AE) * 10;
148
149 if (alarm) {
150 tm->tm_wday = -1;
151 tm->tm_mon = -1;
152 tm->tm_year = -1;
153 tm->tm_yday = -1;
154 tm->tm_isdst = -1;
155 return;
156 }
157
158 tm->tm_wday = (rtc7301_read(priv, RTC7301_DAY_OF_WEEK) & ~RTC7301_AE);
159 tm->tm_mon = rtc7301_read(priv, RTC7301_10_MONTH) * 10 +
160 rtc7301_read(priv, RTC7301_1_MONTH) - 1;
161 year = rtc7301_read(priv, RTC7301_1000_YEAR) * 1000 +
162 rtc7301_read(priv, RTC7301_100_YEAR) * 100 +
163 rtc7301_read(priv, RTC7301_10_YEAR) * 10 +
164 rtc7301_read(priv, RTC7301_1_YEAR);
165
166 tm->tm_year = year - 1900;
167 }
168
169 static void rtc7301_write_time(struct rtc7301_priv *priv, struct rtc_time *tm,
170 bool alarm)
171 {
172 int year;
173
174 rtc7301_write(priv, tm->tm_sec % 10, RTC7301_1_SEC);
175 rtc7301_write(priv, tm->tm_sec / 10, RTC7301_10_SEC);
176
177 rtc7301_write(priv, tm->tm_min % 10, RTC7301_1_MIN);
178 rtc7301_write(priv, tm->tm_min / 10, RTC7301_10_MIN);
179
180 rtc7301_write(priv, tm->tm_hour % 10, RTC7301_1_HOUR);
181 rtc7301_write(priv, tm->tm_hour / 10, RTC7301_10_HOUR);
182
183 rtc7301_write(priv, tm->tm_mday % 10, RTC7301_1_DAY);
184 rtc7301_write(priv, tm->tm_mday / 10, RTC7301_10_DAY);
185
186 /* Don't care for alarm register */
187 rtc7301_write(priv, alarm ? RTC7301_AE : tm->tm_wday,
188 RTC7301_DAY_OF_WEEK);
189
190 if (alarm)
191 return;
192
193 rtc7301_write(priv, (tm->tm_mon + 1) % 10, RTC7301_1_MONTH);
194 rtc7301_write(priv, (tm->tm_mon + 1) / 10, RTC7301_10_MONTH);
195
196 year = tm->tm_year + 1900;
197
198 rtc7301_write(priv, year % 10, RTC7301_1_YEAR);
199 rtc7301_write(priv, (year / 10) % 10, RTC7301_10_YEAR);
200 rtc7301_write(priv, (year / 100) % 10, RTC7301_100_YEAR);
201 rtc7301_write(priv, year / 1000, RTC7301_1000_YEAR);
202 }
203
204 static void rtc7301_alarm_irq(struct rtc7301_priv *priv, unsigned int enabled)
205 {
206 rtc7301_update_bits(priv, RTC7301_ALARM_CONTROL,
207 RTC7301_ALARM_CONTROL_AF |
208 RTC7301_ALARM_CONTROL_AIE,
209 enabled ? RTC7301_ALARM_CONTROL_AIE : 0);
210 }
211
212 static int rtc7301_read_time(struct device *dev, struct rtc_time *tm)
213 {
214 struct rtc7301_priv *priv = dev_get_drvdata(dev);
215 unsigned long flags;
216 int err;
217
218 spin_lock_irqsave(&priv->lock, flags);
219
220 rtc7301_select_bank(priv, 0);
221
222 err = rtc7301_wait_while_busy(priv);
223 if (!err)
224 rtc7301_get_time(priv, tm, false);
225
226 spin_unlock_irqrestore(&priv->lock, flags);
227
228 return err;
229 }
230
231 static int rtc7301_set_time(struct device *dev, struct rtc_time *tm)
232 {
233 struct rtc7301_priv *priv = dev_get_drvdata(dev);
234 unsigned long flags;
235
236 spin_lock_irqsave(&priv->lock, flags);
237
238 rtc7301_stop(priv);
239 udelay(300);
240 rtc7301_select_bank(priv, 0);
241 rtc7301_write_time(priv, tm, false);
242 rtc7301_start(priv);
243
244 spin_unlock_irqrestore(&priv->lock, flags);
245
246 return 0;
247 }
248
249 static int rtc7301_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
250 {
251 struct rtc7301_priv *priv = dev_get_drvdata(dev);
252 unsigned long flags;
253 u8 alrm_ctrl;
254
255 if (priv->irq <= 0)
256 return -EINVAL;
257
258 spin_lock_irqsave(&priv->lock, flags);
259
260 rtc7301_select_bank(priv, 1);
261 rtc7301_get_time(priv, &alarm->time, true);
262
263 alrm_ctrl = rtc7301_read(priv, RTC7301_ALARM_CONTROL);
264
265 alarm->enabled = !!(alrm_ctrl & RTC7301_ALARM_CONTROL_AIE);
266 alarm->pending = !!(alrm_ctrl & RTC7301_ALARM_CONTROL_AF);
267
268 spin_unlock_irqrestore(&priv->lock, flags);
269
270 return 0;
271 }
272
273 static int rtc7301_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
274 {
275 struct rtc7301_priv *priv = dev_get_drvdata(dev);
276 unsigned long flags;
277
278 if (priv->irq <= 0)
279 return -EINVAL;
280
281 spin_lock_irqsave(&priv->lock, flags);
282
283 rtc7301_select_bank(priv, 1);
284 rtc7301_write_time(priv, &alarm->time, true);
285 rtc7301_alarm_irq(priv, alarm->enabled);
286
287 spin_unlock_irqrestore(&priv->lock, flags);
288
289 return 0;
290 }
291
292 static int rtc7301_alarm_irq_enable(struct device *dev, unsigned int enabled)
293 {
294 struct rtc7301_priv *priv = dev_get_drvdata(dev);
295 unsigned long flags;
296
297 if (priv->irq <= 0)
298 return -EINVAL;
299
300 spin_lock_irqsave(&priv->lock, flags);
301
302 rtc7301_select_bank(priv, 1);
303 rtc7301_alarm_irq(priv, enabled);
304
305 spin_unlock_irqrestore(&priv->lock, flags);
306
307 return 0;
308 }
309
310 static const struct rtc_class_ops rtc7301_rtc_ops = {
311 .read_time = rtc7301_read_time,
312 .set_time = rtc7301_set_time,
313 .read_alarm = rtc7301_read_alarm,
314 .set_alarm = rtc7301_set_alarm,
315 .alarm_irq_enable = rtc7301_alarm_irq_enable,
316 };
317
318 static irqreturn_t rtc7301_irq_handler(int irq, void *dev_id)
319 {
320 struct rtc_device *rtc = dev_id;
321 struct rtc7301_priv *priv = dev_get_drvdata(rtc->dev.parent);
322 unsigned long flags;
323 irqreturn_t ret = IRQ_NONE;
324 u8 alrm_ctrl;
325
326 spin_lock_irqsave(&priv->lock, flags);
327
328 rtc7301_select_bank(priv, 1);
329
330 alrm_ctrl = rtc7301_read(priv, RTC7301_ALARM_CONTROL);
331 if (alrm_ctrl & RTC7301_ALARM_CONTROL_AF) {
332 ret = IRQ_HANDLED;
333 rtc7301_alarm_irq(priv, false);
334 rtc_update_irq(rtc, 1, RTC_IRQF | RTC_AF);
335 }
336
337 spin_unlock_irqrestore(&priv->lock, flags);
338
339 return ret;
340 }
341
342 static void rtc7301_init(struct rtc7301_priv *priv)
343 {
344 unsigned long flags;
345
346 spin_lock_irqsave(&priv->lock, flags);
347
348 rtc7301_select_bank(priv, 2);
349 rtc7301_write(priv, 0, RTC7301_TIMER_CONTROL);
350
351 spin_unlock_irqrestore(&priv->lock, flags);
352 }
353
354 static int __init rtc7301_rtc_probe(struct platform_device *dev)
355 {
356 struct resource *res;
357 void __iomem *regs;
358 struct rtc7301_priv *priv;
359 struct rtc_device *rtc;
360 int ret;
361
362 res = platform_get_resource(dev, IORESOURCE_MEM, 0);
363 if (!res)
364 return -ENODEV;
365
366 priv = devm_kzalloc(&dev->dev, sizeof(*priv), GFP_KERNEL);
367 if (!priv)
368 return -ENOMEM;
369
370 regs = devm_ioremap_resource(&dev->dev, res);
371 if (IS_ERR(regs))
372 return PTR_ERR(regs);
373
374 priv->regmap = devm_regmap_init_mmio(&dev->dev, regs,
375 &rtc7301_regmap_config);
376 if (IS_ERR(priv->regmap))
377 return PTR_ERR(priv->regmap);
378
379 priv->irq = platform_get_irq(dev, 0);
380
381 spin_lock_init(&priv->lock);
382 priv->bank = -1;
383
384 rtc7301_init(priv);
385
386 platform_set_drvdata(dev, priv);
387
388 rtc = devm_rtc_device_register(&dev->dev, DRV_NAME, &rtc7301_rtc_ops,
389 THIS_MODULE);
390 if (IS_ERR(rtc))
391 return PTR_ERR(rtc);
392
393 if (priv->irq > 0) {
394 ret = devm_request_irq(&dev->dev, priv->irq,
395 rtc7301_irq_handler, IRQF_SHARED,
396 dev_name(&dev->dev), rtc);
397 if (ret) {
398 priv->irq = 0;
399 dev_err(&dev->dev, "unable to request IRQ\n");
400 } else {
401 device_set_wakeup_capable(&dev->dev, true);
402 }
403 }
404
405 return 0;
406 }
407
408 #ifdef CONFIG_PM_SLEEP
409
410 static int rtc7301_suspend(struct device *dev)
411 {
412 struct rtc7301_priv *priv = dev_get_drvdata(dev);
413
414 if (device_may_wakeup(dev))
415 enable_irq_wake(priv->irq);
416
417 return 0;
418 }
419
420 static int rtc7301_resume(struct device *dev)
421 {
422 struct rtc7301_priv *priv = dev_get_drvdata(dev);
423
424 if (device_may_wakeup(dev))
425 disable_irq_wake(priv->irq);
426
427 return 0;
428 }
429
430 #endif
431
432 static SIMPLE_DEV_PM_OPS(rtc7301_pm_ops, rtc7301_suspend, rtc7301_resume);
433
434 static const struct of_device_id rtc7301_dt_match[] = {
435 { .compatible = "epson,rtc7301sf" },
436 { .compatible = "epson,rtc7301dg" },
437 {}
438 };
439 MODULE_DEVICE_TABLE(of, rtc7301_dt_match);
440
441 static struct platform_driver rtc7301_rtc_driver = {
442 .driver = {
443 .name = DRV_NAME,
444 .of_match_table = rtc7301_dt_match,
445 .pm = &rtc7301_pm_ops,
446 },
447 };
448
449 module_platform_driver_probe(rtc7301_rtc_driver, rtc7301_rtc_probe);
450
451 MODULE_AUTHOR("Akinobu Mita <akinobu.mita@gmail.com>");
452 MODULE_LICENSE("GPL");
453 MODULE_DESCRIPTION("EPSON TOYOCOM RTC-7301SF/DG Driver");
454 MODULE_ALIAS("platform:rtc-r7301");
Linux with added FPC-III support