Version:  2.0.40 2.2.26 2.4.37 3.2 3.3 3.4 3.5 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

Linux/drivers/rtc/rtc-max77686.c

  1 /*
  2  * RTC driver for Maxim MAX77686
  3  *
  4  * Copyright (C) 2012 Samsung Electronics Co.Ltd
  5  *
  6  *  based on rtc-max8997.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 #include <linux/slab.h>
 16 #include <linux/rtc.h>
 17 #include <linux/delay.h>
 18 #include <linux/mutex.h>
 19 #include <linux/module.h>
 20 #include <linux/platform_device.h>
 21 #include <linux/mfd/max77686-private.h>
 22 #include <linux/irqdomain.h>
 23 #include <linux/regmap.h>
 24 
 25 /* RTC Control Register */
 26 #define BCD_EN_SHIFT                    0
 27 #define BCD_EN_MASK                     (1 << BCD_EN_SHIFT)
 28 #define MODEL24_SHIFT                   1
 29 #define MODEL24_MASK                    (1 << MODEL24_SHIFT)
 30 /* RTC Update Register1 */
 31 #define RTC_UDR_SHIFT                   0
 32 #define RTC_UDR_MASK                    (1 << RTC_UDR_SHIFT)
 33 #define RTC_RBUDR_SHIFT                 4
 34 #define RTC_RBUDR_MASK                  (1 << RTC_RBUDR_SHIFT)
 35 /* RTC Hour register */
 36 #define HOUR_PM_SHIFT                   6
 37 #define HOUR_PM_MASK                    (1 << HOUR_PM_SHIFT)
 38 /* RTC Alarm Enable */
 39 #define ALARM_ENABLE_SHIFT              7
 40 #define ALARM_ENABLE_MASK               (1 << ALARM_ENABLE_SHIFT)
 41 
 42 #define MAX77686_RTC_UPDATE_DELAY       16
 43 
 44 enum {
 45         RTC_SEC = 0,
 46         RTC_MIN,
 47         RTC_HOUR,
 48         RTC_WEEKDAY,
 49         RTC_MONTH,
 50         RTC_YEAR,
 51         RTC_DATE,
 52         RTC_NR_TIME
 53 };
 54 
 55 struct max77686_rtc_info {
 56         struct device           *dev;
 57         struct max77686_dev     *max77686;
 58         struct i2c_client       *rtc;
 59         struct rtc_device       *rtc_dev;
 60         struct mutex            lock;
 61 
 62         struct regmap           *regmap;
 63 
 64         int virq;
 65         int rtc_24hr_mode;
 66 };
 67 
 68 enum MAX77686_RTC_OP {
 69         MAX77686_RTC_WRITE,
 70         MAX77686_RTC_READ,
 71 };
 72 
 73 static void max77686_rtc_data_to_tm(u8 *data, struct rtc_time *tm,
 74                                    int rtc_24hr_mode)
 75 {
 76         tm->tm_sec = data[RTC_SEC] & 0x7f;
 77         tm->tm_min = data[RTC_MIN] & 0x7f;
 78         if (rtc_24hr_mode)
 79                 tm->tm_hour = data[RTC_HOUR] & 0x1f;
 80         else {
 81                 tm->tm_hour = data[RTC_HOUR] & 0x0f;
 82                 if (data[RTC_HOUR] & HOUR_PM_MASK)
 83                         tm->tm_hour += 12;
 84         }
 85 
 86         /* Only a single bit is set in data[], so fls() would be equivalent */
 87         tm->tm_wday = ffs(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 max77686_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("%s: MAX77686 RTC cannot handle the year %d."
107                         "Assume it's 2000.\n", __func__, 1900 + tm->tm_year);
108                 return -EINVAL;
109         }
110         return 0;
111 }
112 
113 static int max77686_rtc_update(struct max77686_rtc_info *info,
114         enum MAX77686_RTC_OP op)
115 {
116         int ret;
117         unsigned int data;
118 
119         if (op == MAX77686_RTC_WRITE)
120                 data = 1 << RTC_UDR_SHIFT;
121         else
122                 data = 1 << RTC_RBUDR_SHIFT;
123 
124         ret = regmap_update_bits(info->max77686->rtc_regmap,
125                                  MAX77686_RTC_UPDATE0, data, data);
126         if (ret < 0)
127                 dev_err(info->dev, "%s: fail to write update reg(ret=%d, data=0x%x)\n",
128                                 __func__, ret, data);
129         else {
130                 /* Minimum 16ms delay required before RTC update. */
131                 msleep(MAX77686_RTC_UPDATE_DELAY);
132         }
133 
134         return ret;
135 }
136 
137 static int max77686_rtc_read_time(struct device *dev, struct rtc_time *tm)
138 {
139         struct max77686_rtc_info *info = dev_get_drvdata(dev);
140         u8 data[RTC_NR_TIME];
141         int ret;
142 
143         mutex_lock(&info->lock);
144 
145         ret = max77686_rtc_update(info, MAX77686_RTC_READ);
146         if (ret < 0)
147                 goto out;
148 
149         ret = regmap_bulk_read(info->max77686->rtc_regmap,
150                                 MAX77686_RTC_SEC, data, RTC_NR_TIME);
151         if (ret < 0) {
152                 dev_err(info->dev, "%s: fail to read time reg(%d)\n", __func__, ret);
153                 goto out;
154         }
155 
156         max77686_rtc_data_to_tm(data, tm, info->rtc_24hr_mode);
157 
158         ret = rtc_valid_tm(tm);
159 
160 out:
161         mutex_unlock(&info->lock);
162         return ret;
163 }
164 
165 static int max77686_rtc_set_time(struct device *dev, struct rtc_time *tm)
166 {
167         struct max77686_rtc_info *info = dev_get_drvdata(dev);
168         u8 data[RTC_NR_TIME];
169         int ret;
170 
171         ret = max77686_rtc_tm_to_data(tm, data);
172         if (ret < 0)
173                 return ret;
174 
175         mutex_lock(&info->lock);
176 
177         ret = regmap_bulk_write(info->max77686->rtc_regmap,
178                                  MAX77686_RTC_SEC, data, RTC_NR_TIME);
179         if (ret < 0) {
180                 dev_err(info->dev, "%s: fail to write time reg(%d)\n", __func__,
181                                 ret);
182                 goto out;
183         }
184 
185         ret = max77686_rtc_update(info, MAX77686_RTC_WRITE);
186 
187 out:
188         mutex_unlock(&info->lock);
189         return ret;
190 }
191 
192 static int max77686_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
193 {
194         struct max77686_rtc_info *info = dev_get_drvdata(dev);
195         u8 data[RTC_NR_TIME];
196         unsigned int val;
197         int i, ret;
198 
199         mutex_lock(&info->lock);
200 
201         ret = max77686_rtc_update(info, MAX77686_RTC_READ);
202         if (ret < 0)
203                 goto out;
204 
205         ret = regmap_bulk_read(info->max77686->rtc_regmap,
206                                  MAX77686_ALARM1_SEC, data, RTC_NR_TIME);
207         if (ret < 0) {
208                 dev_err(info->dev, "%s:%d fail to read alarm reg(%d)\n",
209                                 __func__, __LINE__, ret);
210                 goto out;
211         }
212 
213         max77686_rtc_data_to_tm(data, &alrm->time, info->rtc_24hr_mode);
214 
215         alrm->enabled = 0;
216         for (i = 0; i < RTC_NR_TIME; i++) {
217                 if (data[i] & ALARM_ENABLE_MASK) {
218                         alrm->enabled = 1;
219                         break;
220                 }
221         }
222 
223         alrm->pending = 0;
224         ret = regmap_read(info->max77686->regmap, MAX77686_REG_STATUS2, &val);
225         if (ret < 0) {
226                 dev_err(info->dev, "%s:%d fail to read status2 reg(%d)\n",
227                                 __func__, __LINE__, ret);
228                 goto out;
229         }
230 
231         if (val & (1 << 4)) /* RTCA1 */
232                 alrm->pending = 1;
233 
234 out:
235         mutex_unlock(&info->lock);
236         return 0;
237 }
238 
239 static int max77686_rtc_stop_alarm(struct max77686_rtc_info *info)
240 {
241         u8 data[RTC_NR_TIME];
242         int ret, i;
243         struct rtc_time tm;
244 
245         if (!mutex_is_locked(&info->lock))
246                 dev_warn(info->dev, "%s: should have mutex locked\n", __func__);
247 
248         ret = max77686_rtc_update(info, MAX77686_RTC_READ);
249         if (ret < 0)
250                 goto out;
251 
252         ret = regmap_bulk_read(info->max77686->rtc_regmap,
253                                  MAX77686_ALARM1_SEC, data, RTC_NR_TIME);
254         if (ret < 0) {
255                 dev_err(info->dev, "%s: fail to read alarm reg(%d)\n",
256                                 __func__, ret);
257                 goto out;
258         }
259 
260         max77686_rtc_data_to_tm(data, &tm, info->rtc_24hr_mode);
261 
262         for (i = 0; i < RTC_NR_TIME; i++)
263                 data[i] &= ~ALARM_ENABLE_MASK;
264 
265         ret = regmap_bulk_write(info->max77686->rtc_regmap,
266                                  MAX77686_ALARM1_SEC, data, RTC_NR_TIME);
267         if (ret < 0) {
268                 dev_err(info->dev, "%s: fail to write alarm reg(%d)\n",
269                                 __func__, ret);
270                 goto out;
271         }
272 
273         ret = max77686_rtc_update(info, MAX77686_RTC_WRITE);
274 out:
275         return ret;
276 }
277 
278 static int max77686_rtc_start_alarm(struct max77686_rtc_info *info)
279 {
280         u8 data[RTC_NR_TIME];
281         int ret;
282         struct rtc_time tm;
283 
284         if (!mutex_is_locked(&info->lock))
285                 dev_warn(info->dev, "%s: should have mutex locked\n", __func__);
286 
287         ret = max77686_rtc_update(info, MAX77686_RTC_READ);
288         if (ret < 0)
289                 goto out;
290 
291         ret = regmap_bulk_read(info->max77686->rtc_regmap,
292                                  MAX77686_ALARM1_SEC, data, RTC_NR_TIME);
293         if (ret < 0) {
294                 dev_err(info->dev, "%s: fail to read alarm reg(%d)\n",
295                                 __func__, ret);
296                 goto out;
297         }
298 
299         max77686_rtc_data_to_tm(data, &tm, info->rtc_24hr_mode);
300 
301         data[RTC_SEC] |= (1 << ALARM_ENABLE_SHIFT);
302         data[RTC_MIN] |= (1 << ALARM_ENABLE_SHIFT);
303         data[RTC_HOUR] |= (1 << ALARM_ENABLE_SHIFT);
304         data[RTC_WEEKDAY] &= ~ALARM_ENABLE_MASK;
305         if (data[RTC_MONTH] & 0xf)
306                 data[RTC_MONTH] |= (1 << ALARM_ENABLE_SHIFT);
307         if (data[RTC_YEAR] & 0x7f)
308                 data[RTC_YEAR] |= (1 << ALARM_ENABLE_SHIFT);
309         if (data[RTC_DATE] & 0x1f)
310                 data[RTC_DATE] |= (1 << ALARM_ENABLE_SHIFT);
311 
312         ret = regmap_bulk_write(info->max77686->rtc_regmap,
313                                  MAX77686_ALARM1_SEC, data, RTC_NR_TIME);
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 = max77686_rtc_update(info, MAX77686_RTC_WRITE);
321 out:
322         return ret;
323 }
324 
325 static int max77686_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
326 {
327         struct max77686_rtc_info *info = dev_get_drvdata(dev);
328         u8 data[RTC_NR_TIME];
329         int ret;
330 
331         ret = max77686_rtc_tm_to_data(&alrm->time, data);
332         if (ret < 0)
333                 return ret;
334 
335         mutex_lock(&info->lock);
336 
337         ret = max77686_rtc_stop_alarm(info);
338         if (ret < 0)
339                 goto out;
340 
341         ret = regmap_bulk_write(info->max77686->rtc_regmap,
342                                  MAX77686_ALARM1_SEC, data, RTC_NR_TIME);
343 
344         if (ret < 0) {
345                 dev_err(info->dev, "%s: fail to write alarm reg(%d)\n",
346                                 __func__, ret);
347                 goto out;
348         }
349 
350         ret = max77686_rtc_update(info, MAX77686_RTC_WRITE);
351         if (ret < 0)
352                 goto out;
353 
354         if (alrm->enabled)
355                 ret = max77686_rtc_start_alarm(info);
356 out:
357         mutex_unlock(&info->lock);
358         return ret;
359 }
360 
361 static int max77686_rtc_alarm_irq_enable(struct device *dev,
362                                         unsigned int enabled)
363 {
364         struct max77686_rtc_info *info = dev_get_drvdata(dev);
365         int ret;
366 
367         mutex_lock(&info->lock);
368         if (enabled)
369                 ret = max77686_rtc_start_alarm(info);
370         else
371                 ret = max77686_rtc_stop_alarm(info);
372         mutex_unlock(&info->lock);
373 
374         return ret;
375 }
376 
377 static irqreturn_t max77686_rtc_alarm_irq(int irq, void *data)
378 {
379         struct max77686_rtc_info *info = data;
380 
381         dev_info(info->dev, "%s:irq(%d)\n", __func__, irq);
382 
383         rtc_update_irq(info->rtc_dev, 1, RTC_IRQF | RTC_AF);
384 
385         return IRQ_HANDLED;
386 }
387 
388 static const struct rtc_class_ops max77686_rtc_ops = {
389         .read_time = max77686_rtc_read_time,
390         .set_time = max77686_rtc_set_time,
391         .read_alarm = max77686_rtc_read_alarm,
392         .set_alarm = max77686_rtc_set_alarm,
393         .alarm_irq_enable = max77686_rtc_alarm_irq_enable,
394 };
395 
396 static int max77686_rtc_init_reg(struct max77686_rtc_info *info)
397 {
398         u8 data[2];
399         int ret;
400 
401         /* Set RTC control register : Binary mode, 24hour mdoe */
402         data[0] = (1 << BCD_EN_SHIFT) | (1 << MODEL24_SHIFT);
403         data[1] = (0 << BCD_EN_SHIFT) | (1 << MODEL24_SHIFT);
404 
405         info->rtc_24hr_mode = 1;
406 
407         ret = regmap_bulk_write(info->max77686->rtc_regmap, MAX77686_RTC_CONTROLM, data, 2);
408         if (ret < 0) {
409                 dev_err(info->dev, "%s: fail to write controlm reg(%d)\n",
410                                 __func__, ret);
411                 return ret;
412         }
413 
414         ret = max77686_rtc_update(info, MAX77686_RTC_WRITE);
415         return ret;
416 }
417 
418 static int max77686_rtc_probe(struct platform_device *pdev)
419 {
420         struct max77686_dev *max77686 = dev_get_drvdata(pdev->dev.parent);
421         struct max77686_rtc_info *info;
422         int ret;
423 
424         dev_info(&pdev->dev, "%s\n", __func__);
425 
426         info = devm_kzalloc(&pdev->dev, sizeof(struct max77686_rtc_info),
427                                 GFP_KERNEL);
428         if (!info)
429                 return -ENOMEM;
430 
431         mutex_init(&info->lock);
432         info->dev = &pdev->dev;
433         info->max77686 = max77686;
434         info->rtc = max77686->rtc;
435 
436         platform_set_drvdata(pdev, info);
437 
438         ret = max77686_rtc_init_reg(info);
439 
440         if (ret < 0) {
441                 dev_err(&pdev->dev, "Failed to initialize RTC reg:%d\n", ret);
442                 goto err_rtc;
443         }
444 
445         device_init_wakeup(&pdev->dev, 1);
446 
447         info->rtc_dev = devm_rtc_device_register(&pdev->dev, "max77686-rtc",
448                                         &max77686_rtc_ops, THIS_MODULE);
449 
450         if (IS_ERR(info->rtc_dev)) {
451                 ret = PTR_ERR(info->rtc_dev);
452                 dev_err(&pdev->dev, "Failed to register RTC device: %d\n", ret);
453                 if (ret == 0)
454                         ret = -EINVAL;
455                 goto err_rtc;
456         }
457 
458         if (!max77686->rtc_irq_data) {
459                 ret = -EINVAL;
460                 dev_err(&pdev->dev, "%s: no RTC regmap IRQ chip\n", __func__);
461                 goto err_rtc;
462         }
463 
464         info->virq = regmap_irq_get_virq(max77686->rtc_irq_data,
465                                          MAX77686_RTCIRQ_RTCA1);
466         if (!info->virq) {
467                 ret = -ENXIO;
468                 goto err_rtc;
469         }
470 
471         ret = devm_request_threaded_irq(&pdev->dev, info->virq, NULL,
472                                 max77686_rtc_alarm_irq, 0, "rtc-alarm1", info);
473         if (ret < 0)
474                 dev_err(&pdev->dev, "Failed to request alarm IRQ: %d: %d\n",
475                         info->virq, ret);
476 
477 err_rtc:
478         return ret;
479 }
480 
481 #ifdef CONFIG_PM_SLEEP
482 static int max77686_rtc_suspend(struct device *dev)
483 {
484         if (device_may_wakeup(dev)) {
485                 struct max77686_rtc_info *info = dev_get_drvdata(dev);
486 
487                 return enable_irq_wake(info->virq);
488         }
489 
490         return 0;
491 }
492 
493 static int max77686_rtc_resume(struct device *dev)
494 {
495         if (device_may_wakeup(dev)) {
496                 struct max77686_rtc_info *info = dev_get_drvdata(dev);
497 
498                 return disable_irq_wake(info->virq);
499         }
500 
501         return 0;
502 }
503 #endif
504 
505 static SIMPLE_DEV_PM_OPS(max77686_rtc_pm_ops,
506                          max77686_rtc_suspend, max77686_rtc_resume);
507 
508 static const struct platform_device_id rtc_id[] = {
509         { "max77686-rtc", 0 },
510         {},
511 };
512 
513 static struct platform_driver max77686_rtc_driver = {
514         .driver         = {
515                 .name   = "max77686-rtc",
516                 .owner  = THIS_MODULE,
517                 .pm     = &max77686_rtc_pm_ops,
518         },
519         .probe          = max77686_rtc_probe,
520         .id_table       = rtc_id,
521 };
522 
523 module_platform_driver(max77686_rtc_driver);
524 
525 MODULE_DESCRIPTION("Maxim MAX77686 RTC driver");
526 MODULE_AUTHOR("Chiwoong Byun <woong.byun@samsung.com>");
527 MODULE_LICENSE("GPL");
528 

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