Version:  2.0.40 2.2.26 2.4.37 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2

Linux/drivers/rtc/rtc-max8997.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us