This source file includes following definitions.
- max8997_rtc_data_to_tm
- max8997_rtc_tm_to_data
- max8997_rtc_set_update_reg
- max8997_rtc_read_time
- max8997_rtc_set_time
- max8997_rtc_read_alarm
- max8997_rtc_stop_alarm
- max8997_rtc_start_alarm
- max8997_rtc_set_alarm
- max8997_rtc_alarm_irq_enable
- max8997_rtc_alarm_irq
- max8997_rtc_enable_wtsr
- max8997_rtc_enable_smpl
- max8997_rtc_init_reg
- max8997_rtc_probe
- max8997_rtc_shutdown
1
2
3
4
5
6
7
8
9 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
10
11 #include <linux/slab.h>
12 #include <linux/rtc.h>
13 #include <linux/delay.h>
14 #include <linux/mutex.h>
15 #include <linux/module.h>
16 #include <linux/platform_device.h>
17 #include <linux/mfd/max8997-private.h>
18 #include <linux/irqdomain.h>
19
20
21 static int wtsr_en = 1;
22 module_param(wtsr_en, int, 0444);
23 MODULE_PARM_DESC(wtsr_en, "Watchdog Timeout & Software Reset (default=on)");
24
25 static int smpl_en = 1;
26 module_param(smpl_en, int, 0444);
27 MODULE_PARM_DESC(smpl_en, "Sudden Momentary Power Loss (default=on)");
28
29
30 #define BCD_EN_SHIFT 0
31 #define BCD_EN_MASK (1 << BCD_EN_SHIFT)
32 #define MODEL24_SHIFT 1
33 #define MODEL24_MASK (1 << MODEL24_SHIFT)
34
35 #define RTC_UDR_SHIFT 0
36 #define RTC_UDR_MASK (1 << RTC_UDR_SHIFT)
37
38 #define WTSRT_SHIFT 0
39 #define SMPLT_SHIFT 2
40 #define WTSR_EN_SHIFT 6
41 #define SMPL_EN_SHIFT 7
42 #define WTSRT_MASK (3 << WTSRT_SHIFT)
43 #define SMPLT_MASK (3 << SMPLT_SHIFT)
44 #define WTSR_EN_MASK (1 << WTSR_EN_SHIFT)
45 #define SMPL_EN_MASK (1 << SMPL_EN_SHIFT)
46
47 #define HOUR_PM_SHIFT 6
48 #define HOUR_PM_MASK (1 << HOUR_PM_SHIFT)
49
50 #define ALARM_ENABLE_SHIFT 7
51 #define ALARM_ENABLE_MASK (1 << ALARM_ENABLE_SHIFT)
52
53 enum {
54 RTC_SEC = 0,
55 RTC_MIN,
56 RTC_HOUR,
57 RTC_WEEKDAY,
58 RTC_MONTH,
59 RTC_YEAR,
60 RTC_DATE,
61 RTC_NR_TIME
62 };
63
64 struct max8997_rtc_info {
65 struct device *dev;
66 struct max8997_dev *max8997;
67 struct i2c_client *rtc;
68 struct rtc_device *rtc_dev;
69 struct mutex lock;
70 int virq;
71 int rtc_24hr_mode;
72 };
73
74 static void max8997_rtc_data_to_tm(u8 *data, struct rtc_time *tm,
75 int rtc_24hr_mode)
76 {
77 tm->tm_sec = data[RTC_SEC] & 0x7f;
78 tm->tm_min = data[RTC_MIN] & 0x7f;
79 if (rtc_24hr_mode)
80 tm->tm_hour = data[RTC_HOUR] & 0x1f;
81 else {
82 tm->tm_hour = data[RTC_HOUR] & 0x0f;
83 if (data[RTC_HOUR] & HOUR_PM_MASK)
84 tm->tm_hour += 12;
85 }
86
87 tm->tm_wday = fls(data[RTC_WEEKDAY] & 0x7f) - 1;
88 tm->tm_mday = data[RTC_DATE] & 0x1f;
89 tm->tm_mon = (data[RTC_MONTH] & 0x0f) - 1;
90 tm->tm_year = (data[RTC_YEAR] & 0x7f) + 100;
91 tm->tm_yday = 0;
92 tm->tm_isdst = 0;
93 }
94
95 static int max8997_rtc_tm_to_data(struct rtc_time *tm, u8 *data)
96 {
97 data[RTC_SEC] = tm->tm_sec;
98 data[RTC_MIN] = tm->tm_min;
99 data[RTC_HOUR] = tm->tm_hour;
100 data[RTC_WEEKDAY] = 1 << tm->tm_wday;
101 data[RTC_DATE] = tm->tm_mday;
102 data[RTC_MONTH] = tm->tm_mon + 1;
103 data[RTC_YEAR] = tm->tm_year > 100 ? (tm->tm_year - 100) : 0;
104
105 if (tm->tm_year < 100) {
106 pr_warn("RTC cannot handle the year %d. Assume it's 2000.\n",
107 1900 + tm->tm_year);
108 return -EINVAL;
109 }
110 return 0;
111 }
112
113 static inline int max8997_rtc_set_update_reg(struct max8997_rtc_info *info)
114 {
115 int ret;
116
117 ret = max8997_write_reg(info->rtc, MAX8997_RTC_UPDATE1,
118 RTC_UDR_MASK);
119 if (ret < 0)
120 dev_err(info->dev, "%s: fail to write update reg(%d)\n",
121 __func__, ret);
122 else {
123
124
125
126 msleep(20);
127 }
128
129 return ret;
130 }
131
132 static int max8997_rtc_read_time(struct device *dev, struct rtc_time *tm)
133 {
134 struct max8997_rtc_info *info = dev_get_drvdata(dev);
135 u8 data[RTC_NR_TIME];
136 int ret;
137
138 mutex_lock(&info->lock);
139 ret = max8997_bulk_read(info->rtc, MAX8997_RTC_SEC, RTC_NR_TIME, data);
140 mutex_unlock(&info->lock);
141
142 if (ret < 0) {
143 dev_err(info->dev, "%s: fail to read time reg(%d)\n", __func__,
144 ret);
145 return ret;
146 }
147
148 max8997_rtc_data_to_tm(data, tm, info->rtc_24hr_mode);
149
150 return 0;
151 }
152
153 static int max8997_rtc_set_time(struct device *dev, struct rtc_time *tm)
154 {
155 struct max8997_rtc_info *info = dev_get_drvdata(dev);
156 u8 data[RTC_NR_TIME];
157 int ret;
158
159 ret = max8997_rtc_tm_to_data(tm, data);
160 if (ret < 0)
161 return ret;
162
163 mutex_lock(&info->lock);
164
165 ret = max8997_bulk_write(info->rtc, MAX8997_RTC_SEC, RTC_NR_TIME, data);
166 if (ret < 0) {
167 dev_err(info->dev, "%s: fail to write time reg(%d)\n", __func__,
168 ret);
169 goto out;
170 }
171
172 ret = max8997_rtc_set_update_reg(info);
173 out:
174 mutex_unlock(&info->lock);
175 return ret;
176 }
177
178 static int max8997_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
179 {
180 struct max8997_rtc_info *info = dev_get_drvdata(dev);
181 u8 data[RTC_NR_TIME];
182 u8 val;
183 int i, ret;
184
185 mutex_lock(&info->lock);
186
187 ret = max8997_bulk_read(info->rtc, MAX8997_RTC_ALARM1_SEC, RTC_NR_TIME,
188 data);
189 if (ret < 0) {
190 dev_err(info->dev, "%s:%d fail to read alarm reg(%d)\n",
191 __func__, __LINE__, ret);
192 goto out;
193 }
194
195 max8997_rtc_data_to_tm(data, &alrm->time, info->rtc_24hr_mode);
196
197 alrm->enabled = 0;
198 for (i = 0; i < RTC_NR_TIME; i++) {
199 if (data[i] & ALARM_ENABLE_MASK) {
200 alrm->enabled = 1;
201 break;
202 }
203 }
204
205 alrm->pending = 0;
206 ret = max8997_read_reg(info->max8997->i2c, MAX8997_REG_STATUS1, &val);
207 if (ret < 0) {
208 dev_err(info->dev, "%s:%d fail to read status1 reg(%d)\n",
209 __func__, __LINE__, ret);
210 goto out;
211 }
212
213 if (val & (1 << 4))
214 alrm->pending = 1;
215
216 out:
217 mutex_unlock(&info->lock);
218 return ret;
219 }
220
221 static int max8997_rtc_stop_alarm(struct max8997_rtc_info *info)
222 {
223 u8 data[RTC_NR_TIME];
224 int ret, i;
225
226 if (!mutex_is_locked(&info->lock))
227 dev_warn(info->dev, "%s: should have mutex locked\n", __func__);
228
229 ret = max8997_bulk_read(info->rtc, MAX8997_RTC_ALARM1_SEC, RTC_NR_TIME,
230 data);
231 if (ret < 0) {
232 dev_err(info->dev, "%s: fail to read alarm reg(%d)\n",
233 __func__, ret);
234 goto out;
235 }
236
237 for (i = 0; i < RTC_NR_TIME; i++)
238 data[i] &= ~ALARM_ENABLE_MASK;
239
240 ret = max8997_bulk_write(info->rtc, MAX8997_RTC_ALARM1_SEC, RTC_NR_TIME,
241 data);
242 if (ret < 0) {
243 dev_err(info->dev, "%s: fail to write alarm reg(%d)\n",
244 __func__, ret);
245 goto out;
246 }
247
248 ret = max8997_rtc_set_update_reg(info);
249 out:
250 return ret;
251 }
252
253 static int max8997_rtc_start_alarm(struct max8997_rtc_info *info)
254 {
255 u8 data[RTC_NR_TIME];
256 int ret;
257
258 if (!mutex_is_locked(&info->lock))
259 dev_warn(info->dev, "%s: should have mutex locked\n", __func__);
260
261 ret = max8997_bulk_read(info->rtc, MAX8997_RTC_ALARM1_SEC, RTC_NR_TIME,
262 data);
263 if (ret < 0) {
264 dev_err(info->dev, "%s: fail to read alarm reg(%d)\n",
265 __func__, ret);
266 goto out;
267 }
268
269 data[RTC_SEC] |= (1 << ALARM_ENABLE_SHIFT);
270 data[RTC_MIN] |= (1 << ALARM_ENABLE_SHIFT);
271 data[RTC_HOUR] |= (1 << ALARM_ENABLE_SHIFT);
272 data[RTC_WEEKDAY] &= ~ALARM_ENABLE_MASK;
273 if (data[RTC_MONTH] & 0xf)
274 data[RTC_MONTH] |= (1 << ALARM_ENABLE_SHIFT);
275 if (data[RTC_YEAR] & 0x7f)
276 data[RTC_YEAR] |= (1 << ALARM_ENABLE_SHIFT);
277 if (data[RTC_DATE] & 0x1f)
278 data[RTC_DATE] |= (1 << ALARM_ENABLE_SHIFT);
279
280 ret = max8997_bulk_write(info->rtc, MAX8997_RTC_ALARM1_SEC, RTC_NR_TIME,
281 data);
282 if (ret < 0) {
283 dev_err(info->dev, "%s: fail to write alarm reg(%d)\n",
284 __func__, ret);
285 goto out;
286 }
287
288 ret = max8997_rtc_set_update_reg(info);
289 out:
290 return ret;
291 }
292 static int max8997_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
293 {
294 struct max8997_rtc_info *info = dev_get_drvdata(dev);
295 u8 data[RTC_NR_TIME];
296 int ret;
297
298 ret = max8997_rtc_tm_to_data(&alrm->time, data);
299 if (ret < 0)
300 return ret;
301
302 dev_info(info->dev, "%s: %d-%02d-%02d %02d:%02d:%02d\n", __func__,
303 data[RTC_YEAR] + 2000, data[RTC_MONTH], data[RTC_DATE],
304 data[RTC_HOUR], data[RTC_MIN], data[RTC_SEC]);
305
306 mutex_lock(&info->lock);
307
308 ret = max8997_rtc_stop_alarm(info);
309 if (ret < 0)
310 goto out;
311
312 ret = max8997_bulk_write(info->rtc, MAX8997_RTC_ALARM1_SEC, RTC_NR_TIME,
313 data);
314 if (ret < 0) {
315 dev_err(info->dev, "%s: fail to write alarm reg(%d)\n",
316 __func__, ret);
317 goto out;
318 }
319
320 ret = max8997_rtc_set_update_reg(info);
321 if (ret < 0)
322 goto out;
323
324 if (alrm->enabled)
325 ret = max8997_rtc_start_alarm(info);
326 out:
327 mutex_unlock(&info->lock);
328 return ret;
329 }
330
331 static int max8997_rtc_alarm_irq_enable(struct device *dev,
332 unsigned int enabled)
333 {
334 struct max8997_rtc_info *info = dev_get_drvdata(dev);
335 int ret;
336
337 mutex_lock(&info->lock);
338 if (enabled)
339 ret = max8997_rtc_start_alarm(info);
340 else
341 ret = max8997_rtc_stop_alarm(info);
342 mutex_unlock(&info->lock);
343
344 return ret;
345 }
346
347 static irqreturn_t max8997_rtc_alarm_irq(int irq, void *data)
348 {
349 struct max8997_rtc_info *info = data;
350
351 dev_info(info->dev, "%s:irq(%d)\n", __func__, irq);
352
353 rtc_update_irq(info->rtc_dev, 1, RTC_IRQF | RTC_AF);
354
355 return IRQ_HANDLED;
356 }
357
358 static const struct rtc_class_ops max8997_rtc_ops = {
359 .read_time = max8997_rtc_read_time,
360 .set_time = max8997_rtc_set_time,
361 .read_alarm = max8997_rtc_read_alarm,
362 .set_alarm = max8997_rtc_set_alarm,
363 .alarm_irq_enable = max8997_rtc_alarm_irq_enable,
364 };
365
366 static void max8997_rtc_enable_wtsr(struct max8997_rtc_info *info, bool enable)
367 {
368 int ret;
369 u8 val, mask;
370
371 if (!wtsr_en)
372 return;
373
374 if (enable)
375 val = (1 << WTSR_EN_SHIFT) | (3 << WTSRT_SHIFT);
376 else
377 val = 0;
378
379 mask = WTSR_EN_MASK | WTSRT_MASK;
380
381 dev_info(info->dev, "%s: %s WTSR\n", __func__,
382 enable ? "enable" : "disable");
383
384 ret = max8997_update_reg(info->rtc, MAX8997_RTC_WTSR_SMPL, val, mask);
385 if (ret < 0) {
386 dev_err(info->dev, "%s: fail to update WTSR reg(%d)\n",
387 __func__, ret);
388 return;
389 }
390
391 max8997_rtc_set_update_reg(info);
392 }
393
394 static void max8997_rtc_enable_smpl(struct max8997_rtc_info *info, bool enable)
395 {
396 int ret;
397 u8 val, mask;
398
399 if (!smpl_en)
400 return;
401
402 if (enable)
403 val = (1 << SMPL_EN_SHIFT) | (0 << SMPLT_SHIFT);
404 else
405 val = 0;
406
407 mask = SMPL_EN_MASK | SMPLT_MASK;
408
409 dev_info(info->dev, "%s: %s SMPL\n", __func__,
410 enable ? "enable" : "disable");
411
412 ret = max8997_update_reg(info->rtc, MAX8997_RTC_WTSR_SMPL, val, mask);
413 if (ret < 0) {
414 dev_err(info->dev, "%s: fail to update SMPL reg(%d)\n",
415 __func__, ret);
416 return;
417 }
418
419 max8997_rtc_set_update_reg(info);
420
421 val = 0;
422 max8997_read_reg(info->rtc, MAX8997_RTC_WTSR_SMPL, &val);
423 pr_info("WTSR_SMPL(0x%02x)\n", val);
424 }
425
426 static int max8997_rtc_init_reg(struct max8997_rtc_info *info)
427 {
428 u8 data[2];
429 int ret;
430
431
432 data[0] = (1 << BCD_EN_SHIFT) | (1 << MODEL24_SHIFT);
433 data[1] = (0 << BCD_EN_SHIFT) | (1 << MODEL24_SHIFT);
434
435 info->rtc_24hr_mode = 1;
436
437 ret = max8997_bulk_write(info->rtc, MAX8997_RTC_CTRLMASK, 2, data);
438 if (ret < 0) {
439 dev_err(info->dev, "%s: fail to write controlm reg(%d)\n",
440 __func__, ret);
441 return ret;
442 }
443
444 ret = max8997_rtc_set_update_reg(info);
445 return ret;
446 }
447
448 static int max8997_rtc_probe(struct platform_device *pdev)
449 {
450 struct max8997_dev *max8997 = dev_get_drvdata(pdev->dev.parent);
451 struct max8997_rtc_info *info;
452 int ret, virq;
453
454 info = devm_kzalloc(&pdev->dev, sizeof(struct max8997_rtc_info),
455 GFP_KERNEL);
456 if (!info)
457 return -ENOMEM;
458
459 mutex_init(&info->lock);
460 info->dev = &pdev->dev;
461 info->max8997 = max8997;
462 info->rtc = max8997->rtc;
463
464 platform_set_drvdata(pdev, info);
465
466 ret = max8997_rtc_init_reg(info);
467
468 if (ret < 0) {
469 dev_err(&pdev->dev, "Failed to initialize RTC reg:%d\n", ret);
470 return ret;
471 }
472
473 max8997_rtc_enable_wtsr(info, true);
474 max8997_rtc_enable_smpl(info, true);
475
476 device_init_wakeup(&pdev->dev, 1);
477
478 info->rtc_dev = devm_rtc_device_register(&pdev->dev, "max8997-rtc",
479 &max8997_rtc_ops, THIS_MODULE);
480
481 if (IS_ERR(info->rtc_dev)) {
482 ret = PTR_ERR(info->rtc_dev);
483 dev_err(&pdev->dev, "Failed to register RTC device: %d\n", ret);
484 return ret;
485 }
486
487 virq = irq_create_mapping(max8997->irq_domain, MAX8997_PMICIRQ_RTCA1);
488 if (!virq) {
489 dev_err(&pdev->dev, "Failed to create mapping alarm IRQ\n");
490 ret = -ENXIO;
491 goto err_out;
492 }
493 info->virq = virq;
494
495 ret = devm_request_threaded_irq(&pdev->dev, virq, NULL,
496 max8997_rtc_alarm_irq, 0,
497 "rtc-alarm0", info);
498 if (ret < 0)
499 dev_err(&pdev->dev, "Failed to request alarm IRQ: %d: %d\n",
500 info->virq, ret);
501
502 err_out:
503 return ret;
504 }
505
506 static void max8997_rtc_shutdown(struct platform_device *pdev)
507 {
508 struct max8997_rtc_info *info = platform_get_drvdata(pdev);
509
510 max8997_rtc_enable_wtsr(info, false);
511 max8997_rtc_enable_smpl(info, false);
512 }
513
514 static const struct platform_device_id rtc_id[] = {
515 { "max8997-rtc", 0 },
516 {},
517 };
518 MODULE_DEVICE_TABLE(platform, rtc_id);
519
520 static struct platform_driver max8997_rtc_driver = {
521 .driver = {
522 .name = "max8997-rtc",
523 },
524 .probe = max8997_rtc_probe,
525 .shutdown = max8997_rtc_shutdown,
526 .id_table = rtc_id,
527 };
528
529 module_platform_driver(max8997_rtc_driver);
530
531 MODULE_DESCRIPTION("Maxim MAX8997 RTC driver");
532 MODULE_AUTHOR("<ms925.kim@samsung.com>");
533 MODULE_LICENSE("GPL");