Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 3.1 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

Linux/drivers/rtc/rtc-s5m.c

  1 /*
  2  * Copyright (c) 2013 Samsung Electronics Co., Ltd
  3  *      http://www.samsung.com
  4  *
  5  *  Copyright (C) 2013 Google, Inc
  6  *
  7  *  This program is free software; you can redistribute it and/or modify
  8  *  it under the terms of the GNU General Public License as published by
  9  *  the Free Software Foundation; either version 2 of the License, or
 10  *  (at your option) any later version.
 11  *
 12  *  This program is distributed in the hope that it will be useful,
 13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 15  *  GNU General Public License for more details.
 16  */
 17 
 18 #include <linux/module.h>
 19 #include <linux/i2c.h>
 20 #include <linux/slab.h>
 21 #include <linux/bcd.h>
 22 #include <linux/bitops.h>
 23 #include <linux/regmap.h>
 24 #include <linux/rtc.h>
 25 #include <linux/delay.h>
 26 #include <linux/platform_device.h>
 27 #include <linux/mfd/samsung/core.h>
 28 #include <linux/mfd/samsung/irq.h>
 29 #include <linux/mfd/samsung/rtc.h>
 30 
 31 /*
 32  * Maximum number of retries for checking changes in UDR field
 33  * of SEC_RTC_UDR_CON register (to limit possible endless loop).
 34  *
 35  * After writing to RTC registers (setting time or alarm) read the UDR field
 36  * in SEC_RTC_UDR_CON register. UDR is auto-cleared when data have
 37  * been transferred.
 38  */
 39 #define UDR_READ_RETRY_CNT      5
 40 
 41 struct s5m_rtc_info {
 42         struct device *dev;
 43         struct sec_pmic_dev *s5m87xx;
 44         struct regmap *regmap;
 45         struct rtc_device *rtc_dev;
 46         int irq;
 47         int device_type;
 48         int rtc_24hr_mode;
 49         bool wtsr_smpl;
 50 };
 51 
 52 static void s5m8767_data_to_tm(u8 *data, struct rtc_time *tm,
 53                                int rtc_24hr_mode)
 54 {
 55         tm->tm_sec = data[RTC_SEC] & 0x7f;
 56         tm->tm_min = data[RTC_MIN] & 0x7f;
 57         if (rtc_24hr_mode) {
 58                 tm->tm_hour = data[RTC_HOUR] & 0x1f;
 59         } else {
 60                 tm->tm_hour = data[RTC_HOUR] & 0x0f;
 61                 if (data[RTC_HOUR] & HOUR_PM_MASK)
 62                         tm->tm_hour += 12;
 63         }
 64 
 65         tm->tm_wday = ffs(data[RTC_WEEKDAY] & 0x7f);
 66         tm->tm_mday = data[RTC_DATE] & 0x1f;
 67         tm->tm_mon = (data[RTC_MONTH] & 0x0f) - 1;
 68         tm->tm_year = (data[RTC_YEAR1] & 0x7f) + 100;
 69         tm->tm_yday = 0;
 70         tm->tm_isdst = 0;
 71 }
 72 
 73 static int s5m8767_tm_to_data(struct rtc_time *tm, u8 *data)
 74 {
 75         data[RTC_SEC] = tm->tm_sec;
 76         data[RTC_MIN] = tm->tm_min;
 77 
 78         if (tm->tm_hour >= 12)
 79                 data[RTC_HOUR] = tm->tm_hour | HOUR_PM_MASK;
 80         else
 81                 data[RTC_HOUR] = tm->tm_hour & ~HOUR_PM_MASK;
 82 
 83         data[RTC_WEEKDAY] = 1 << tm->tm_wday;
 84         data[RTC_DATE] = tm->tm_mday;
 85         data[RTC_MONTH] = tm->tm_mon + 1;
 86         data[RTC_YEAR1] = tm->tm_year > 100 ? (tm->tm_year - 100) : 0;
 87 
 88         if (tm->tm_year < 100) {
 89                 pr_err("s5m8767 RTC cannot handle the year %d.\n",
 90                        1900 + tm->tm_year);
 91                 return -EINVAL;
 92         } else {
 93                 return 0;
 94         }
 95 }
 96 
 97 /*
 98  * Read RTC_UDR_CON register and wait till UDR field is cleared.
 99  * This indicates that time/alarm update ended.
100  */
101 static inline int s5m8767_wait_for_udr_update(struct s5m_rtc_info *info)
102 {
103         int ret, retry = UDR_READ_RETRY_CNT;
104         unsigned int data;
105 
106         do {
107                 ret = regmap_read(info->regmap, SEC_RTC_UDR_CON, &data);
108         } while (--retry && (data & RTC_UDR_MASK) && !ret);
109 
110         if (!retry)
111                 dev_err(info->dev, "waiting for UDR update, reached max number of retries\n");
112 
113         return ret;
114 }
115 
116 static inline int s5m8767_rtc_set_time_reg(struct s5m_rtc_info *info)
117 {
118         int ret;
119         unsigned int data;
120 
121         ret = regmap_read(info->regmap, SEC_RTC_UDR_CON, &data);
122         if (ret < 0) {
123                 dev_err(info->dev, "failed to read update reg(%d)\n", ret);
124                 return ret;
125         }
126 
127         data |= RTC_TIME_EN_MASK;
128         data |= RTC_UDR_MASK;
129 
130         ret = regmap_write(info->regmap, SEC_RTC_UDR_CON, data);
131         if (ret < 0) {
132                 dev_err(info->dev, "failed to write update reg(%d)\n", ret);
133                 return ret;
134         }
135 
136         ret = s5m8767_wait_for_udr_update(info);
137 
138         return ret;
139 }
140 
141 static inline int s5m8767_rtc_set_alarm_reg(struct s5m_rtc_info *info)
142 {
143         int ret;
144         unsigned int data;
145 
146         ret = regmap_read(info->regmap, SEC_RTC_UDR_CON, &data);
147         if (ret < 0) {
148                 dev_err(info->dev, "%s: fail to read update reg(%d)\n",
149                         __func__, ret);
150                 return ret;
151         }
152 
153         data &= ~RTC_TIME_EN_MASK;
154         data |= RTC_UDR_MASK;
155 
156         ret = regmap_write(info->regmap, SEC_RTC_UDR_CON, data);
157         if (ret < 0) {
158                 dev_err(info->dev, "%s: fail to write update reg(%d)\n",
159                         __func__, ret);
160                 return ret;
161         }
162 
163         ret = s5m8767_wait_for_udr_update(info);
164 
165         return ret;
166 }
167 
168 static void s5m8763_data_to_tm(u8 *data, struct rtc_time *tm)
169 {
170         tm->tm_sec = bcd2bin(data[RTC_SEC]);
171         tm->tm_min = bcd2bin(data[RTC_MIN]);
172 
173         if (data[RTC_HOUR] & HOUR_12) {
174                 tm->tm_hour = bcd2bin(data[RTC_HOUR] & 0x1f);
175                 if (data[RTC_HOUR] & HOUR_PM)
176                         tm->tm_hour += 12;
177         } else {
178                 tm->tm_hour = bcd2bin(data[RTC_HOUR] & 0x3f);
179         }
180 
181         tm->tm_wday = data[RTC_WEEKDAY] & 0x07;
182         tm->tm_mday = bcd2bin(data[RTC_DATE]);
183         tm->tm_mon = bcd2bin(data[RTC_MONTH]);
184         tm->tm_year = bcd2bin(data[RTC_YEAR1]) + bcd2bin(data[RTC_YEAR2]) * 100;
185         tm->tm_year -= 1900;
186 }
187 
188 static void s5m8763_tm_to_data(struct rtc_time *tm, u8 *data)
189 {
190         data[RTC_SEC] = bin2bcd(tm->tm_sec);
191         data[RTC_MIN] = bin2bcd(tm->tm_min);
192         data[RTC_HOUR] = bin2bcd(tm->tm_hour);
193         data[RTC_WEEKDAY] = tm->tm_wday;
194         data[RTC_DATE] = bin2bcd(tm->tm_mday);
195         data[RTC_MONTH] = bin2bcd(tm->tm_mon);
196         data[RTC_YEAR1] = bin2bcd(tm->tm_year % 100);
197         data[RTC_YEAR2] = bin2bcd((tm->tm_year + 1900) / 100);
198 }
199 
200 static int s5m_rtc_read_time(struct device *dev, struct rtc_time *tm)
201 {
202         struct s5m_rtc_info *info = dev_get_drvdata(dev);
203         u8 data[8];
204         int ret;
205 
206         ret = regmap_bulk_read(info->regmap, SEC_RTC_SEC, data, 8);
207         if (ret < 0)
208                 return ret;
209 
210         switch (info->device_type) {
211         case S5M8763X:
212                 s5m8763_data_to_tm(data, tm);
213                 break;
214 
215         case S5M8767X:
216                 s5m8767_data_to_tm(data, tm, info->rtc_24hr_mode);
217                 break;
218 
219         default:
220                 return -EINVAL;
221         }
222 
223         dev_dbg(dev, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__,
224                 1900 + tm->tm_year, 1 + tm->tm_mon, tm->tm_mday,
225                 tm->tm_hour, tm->tm_min, tm->tm_sec, tm->tm_wday);
226 
227         return rtc_valid_tm(tm);
228 }
229 
230 static int s5m_rtc_set_time(struct device *dev, struct rtc_time *tm)
231 {
232         struct s5m_rtc_info *info = dev_get_drvdata(dev);
233         u8 data[8];
234         int ret = 0;
235 
236         switch (info->device_type) {
237         case S5M8763X:
238                 s5m8763_tm_to_data(tm, data);
239                 break;
240         case S5M8767X:
241                 ret = s5m8767_tm_to_data(tm, data);
242                 break;
243         default:
244                 return -EINVAL;
245         }
246 
247         if (ret < 0)
248                 return ret;
249 
250         dev_dbg(dev, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__,
251                 1900 + tm->tm_year, 1 + tm->tm_mon, tm->tm_mday,
252                 tm->tm_hour, tm->tm_min, tm->tm_sec, tm->tm_wday);
253 
254         ret = regmap_raw_write(info->regmap, SEC_RTC_SEC, data, 8);
255         if (ret < 0)
256                 return ret;
257 
258         ret = s5m8767_rtc_set_time_reg(info);
259 
260         return ret;
261 }
262 
263 static int s5m_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
264 {
265         struct s5m_rtc_info *info = dev_get_drvdata(dev);
266         u8 data[8];
267         unsigned int val;
268         int ret, i;
269 
270         ret = regmap_bulk_read(info->regmap, SEC_ALARM0_SEC, data, 8);
271         if (ret < 0)
272                 return ret;
273 
274         switch (info->device_type) {
275         case S5M8763X:
276                 s5m8763_data_to_tm(data, &alrm->time);
277                 ret = regmap_read(info->regmap, SEC_ALARM0_CONF, &val);
278                 if (ret < 0)
279                         return ret;
280 
281                 alrm->enabled = !!val;
282 
283                 ret = regmap_read(info->regmap, SEC_RTC_STATUS, &val);
284                 if (ret < 0)
285                         return ret;
286 
287                 break;
288 
289         case S5M8767X:
290                 s5m8767_data_to_tm(data, &alrm->time, info->rtc_24hr_mode);
291                 dev_dbg(dev, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__,
292                         1900 + alrm->time.tm_year, 1 + alrm->time.tm_mon,
293                         alrm->time.tm_mday, alrm->time.tm_hour,
294                         alrm->time.tm_min, alrm->time.tm_sec,
295                         alrm->time.tm_wday);
296 
297                 alrm->enabled = 0;
298                 for (i = 0; i < 7; i++) {
299                         if (data[i] & ALARM_ENABLE_MASK) {
300                                 alrm->enabled = 1;
301                                 break;
302                         }
303                 }
304 
305                 alrm->pending = 0;
306                 ret = regmap_read(info->regmap, SEC_RTC_STATUS, &val);
307                 if (ret < 0)
308                         return ret;
309                 break;
310 
311         default:
312                 return -EINVAL;
313         }
314 
315         if (val & ALARM0_STATUS)
316                 alrm->pending = 1;
317         else
318                 alrm->pending = 0;
319 
320         return 0;
321 }
322 
323 static int s5m_rtc_stop_alarm(struct s5m_rtc_info *info)
324 {
325         u8 data[8];
326         int ret, i;
327         struct rtc_time tm;
328 
329         ret = regmap_bulk_read(info->regmap, SEC_ALARM0_SEC, data, 8);
330         if (ret < 0)
331                 return ret;
332 
333         s5m8767_data_to_tm(data, &tm, info->rtc_24hr_mode);
334         dev_dbg(info->dev, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__,
335                 1900 + tm.tm_year, 1 + tm.tm_mon, tm.tm_mday,
336                 tm.tm_hour, tm.tm_min, tm.tm_sec, tm.tm_wday);
337 
338         switch (info->device_type) {
339         case S5M8763X:
340                 ret = regmap_write(info->regmap, SEC_ALARM0_CONF, 0);
341                 break;
342 
343         case S5M8767X:
344                 for (i = 0; i < 7; i++)
345                         data[i] &= ~ALARM_ENABLE_MASK;
346 
347                 ret = regmap_raw_write(info->regmap, SEC_ALARM0_SEC, data, 8);
348                 if (ret < 0)
349                         return ret;
350 
351                 ret = s5m8767_rtc_set_alarm_reg(info);
352 
353                 break;
354 
355         default:
356                 return -EINVAL;
357         }
358 
359         return ret;
360 }
361 
362 static int s5m_rtc_start_alarm(struct s5m_rtc_info *info)
363 {
364         int ret;
365         u8 data[8];
366         u8 alarm0_conf;
367         struct rtc_time tm;
368 
369         ret = regmap_bulk_read(info->regmap, SEC_ALARM0_SEC, data, 8);
370         if (ret < 0)
371                 return ret;
372 
373         s5m8767_data_to_tm(data, &tm, info->rtc_24hr_mode);
374         dev_dbg(info->dev, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__,
375                 1900 + tm.tm_year, 1 + tm.tm_mon, tm.tm_mday,
376                 tm.tm_hour, tm.tm_min, tm.tm_sec, tm.tm_wday);
377 
378         switch (info->device_type) {
379         case S5M8763X:
380                 alarm0_conf = 0x77;
381                 ret = regmap_write(info->regmap, SEC_ALARM0_CONF, alarm0_conf);
382                 break;
383 
384         case S5M8767X:
385                 data[RTC_SEC] |= ALARM_ENABLE_MASK;
386                 data[RTC_MIN] |= ALARM_ENABLE_MASK;
387                 data[RTC_HOUR] |= ALARM_ENABLE_MASK;
388                 data[RTC_WEEKDAY] &= ~ALARM_ENABLE_MASK;
389                 if (data[RTC_DATE] & 0x1f)
390                         data[RTC_DATE] |= ALARM_ENABLE_MASK;
391                 if (data[RTC_MONTH] & 0xf)
392                         data[RTC_MONTH] |= ALARM_ENABLE_MASK;
393                 if (data[RTC_YEAR1] & 0x7f)
394                         data[RTC_YEAR1] |= ALARM_ENABLE_MASK;
395 
396                 ret = regmap_raw_write(info->regmap, SEC_ALARM0_SEC, data, 8);
397                 if (ret < 0)
398                         return ret;
399                 ret = s5m8767_rtc_set_alarm_reg(info);
400 
401                 break;
402 
403         default:
404                 return -EINVAL;
405         }
406 
407         return ret;
408 }
409 
410 static int s5m_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
411 {
412         struct s5m_rtc_info *info = dev_get_drvdata(dev);
413         u8 data[8];
414         int ret;
415 
416         switch (info->device_type) {
417         case S5M8763X:
418                 s5m8763_tm_to_data(&alrm->time, data);
419                 break;
420 
421         case S5M8767X:
422                 s5m8767_tm_to_data(&alrm->time, data);
423                 break;
424 
425         default:
426                 return -EINVAL;
427         }
428 
429         dev_dbg(dev, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__,
430                 1900 + alrm->time.tm_year, 1 + alrm->time.tm_mon,
431                 alrm->time.tm_mday, alrm->time.tm_hour, alrm->time.tm_min,
432                 alrm->time.tm_sec, alrm->time.tm_wday);
433 
434         ret = s5m_rtc_stop_alarm(info);
435         if (ret < 0)
436                 return ret;
437 
438         ret = regmap_raw_write(info->regmap, SEC_ALARM0_SEC, data, 8);
439         if (ret < 0)
440                 return ret;
441 
442         ret = s5m8767_rtc_set_alarm_reg(info);
443         if (ret < 0)
444                 return ret;
445 
446         if (alrm->enabled)
447                 ret = s5m_rtc_start_alarm(info);
448 
449         return ret;
450 }
451 
452 static int s5m_rtc_alarm_irq_enable(struct device *dev,
453                                     unsigned int enabled)
454 {
455         struct s5m_rtc_info *info = dev_get_drvdata(dev);
456 
457         if (enabled)
458                 return s5m_rtc_start_alarm(info);
459         else
460                 return s5m_rtc_stop_alarm(info);
461 }
462 
463 static irqreturn_t s5m_rtc_alarm_irq(int irq, void *data)
464 {
465         struct s5m_rtc_info *info = data;
466 
467         rtc_update_irq(info->rtc_dev, 1, RTC_IRQF | RTC_AF);
468 
469         return IRQ_HANDLED;
470 }
471 
472 static const struct rtc_class_ops s5m_rtc_ops = {
473         .read_time = s5m_rtc_read_time,
474         .set_time = s5m_rtc_set_time,
475         .read_alarm = s5m_rtc_read_alarm,
476         .set_alarm = s5m_rtc_set_alarm,
477         .alarm_irq_enable = s5m_rtc_alarm_irq_enable,
478 };
479 
480 static void s5m_rtc_enable_wtsr(struct s5m_rtc_info *info, bool enable)
481 {
482         int ret;
483         ret = regmap_update_bits(info->regmap, SEC_WTSR_SMPL_CNTL,
484                                  WTSR_ENABLE_MASK,
485                                  enable ? WTSR_ENABLE_MASK : 0);
486         if (ret < 0)
487                 dev_err(info->dev, "%s: fail to update WTSR reg(%d)\n",
488                         __func__, ret);
489 }
490 
491 static void s5m_rtc_enable_smpl(struct s5m_rtc_info *info, bool enable)
492 {
493         int ret;
494         ret = regmap_update_bits(info->regmap, SEC_WTSR_SMPL_CNTL,
495                                  SMPL_ENABLE_MASK,
496                                  enable ? SMPL_ENABLE_MASK : 0);
497         if (ret < 0)
498                 dev_err(info->dev, "%s: fail to update SMPL reg(%d)\n",
499                         __func__, ret);
500 }
501 
502 static int s5m8767_rtc_init_reg(struct s5m_rtc_info *info)
503 {
504         u8 data[2];
505         unsigned int tp_read;
506         int ret;
507         struct rtc_time tm;
508 
509         ret = regmap_read(info->regmap, SEC_RTC_UDR_CON, &tp_read);
510         if (ret < 0) {
511                 dev_err(info->dev, "%s: fail to read control reg(%d)\n",
512                         __func__, ret);
513                 return ret;
514         }
515 
516         /* Set RTC control register : Binary mode, 24hour mode */
517         data[0] = (1 << BCD_EN_SHIFT) | (1 << MODEL24_SHIFT);
518         data[1] = (0 << BCD_EN_SHIFT) | (1 << MODEL24_SHIFT);
519 
520         info->rtc_24hr_mode = 1;
521         ret = regmap_raw_write(info->regmap, SEC_ALARM0_CONF, data, 2);
522         if (ret < 0) {
523                 dev_err(info->dev, "%s: fail to write controlm reg(%d)\n",
524                         __func__, ret);
525                 return ret;
526         }
527 
528         /* In first boot time, Set rtc time to 1/1/2012 00:00:00(SUN) */
529         if ((tp_read & RTC_TCON_MASK) == 0) {
530                 dev_dbg(info->dev, "rtc init\n");
531                 tm.tm_sec = 0;
532                 tm.tm_min = 0;
533                 tm.tm_hour = 0;
534                 tm.tm_wday = 0;
535                 tm.tm_mday = 1;
536                 tm.tm_mon = 0;
537                 tm.tm_year = 112;
538                 tm.tm_yday = 0;
539                 tm.tm_isdst = 0;
540                 ret = s5m_rtc_set_time(info->dev, &tm);
541         }
542 
543         ret = regmap_update_bits(info->regmap, SEC_RTC_UDR_CON,
544                                  RTC_TCON_MASK, tp_read | RTC_TCON_MASK);
545         if (ret < 0)
546                 dev_err(info->dev, "%s: fail to update TCON reg(%d)\n",
547                         __func__, ret);
548 
549         return ret;
550 }
551 
552 static int s5m_rtc_probe(struct platform_device *pdev)
553 {
554         struct sec_pmic_dev *s5m87xx = dev_get_drvdata(pdev->dev.parent);
555         struct sec_platform_data *pdata = s5m87xx->pdata;
556         struct s5m_rtc_info *info;
557         int ret;
558 
559         if (!pdata) {
560                 dev_err(pdev->dev.parent, "Platform data not supplied\n");
561                 return -ENODEV;
562         }
563 
564         info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
565         if (!info)
566                 return -ENOMEM;
567 
568         info->dev = &pdev->dev;
569         info->s5m87xx = s5m87xx;
570         info->regmap = s5m87xx->regmap_rtc;
571         info->device_type = s5m87xx->device_type;
572         info->wtsr_smpl = s5m87xx->wtsr_smpl;
573 
574         switch (pdata->device_type) {
575         case S5M8763X:
576                 info->irq = regmap_irq_get_virq(s5m87xx->irq_data,
577                                 S5M8763_IRQ_ALARM0);
578                 break;
579 
580         case S5M8767X:
581                 info->irq = regmap_irq_get_virq(s5m87xx->irq_data,
582                                 S5M8767_IRQ_RTCA1);
583                 break;
584 
585         default:
586                 ret = -EINVAL;
587                 dev_err(&pdev->dev, "Unsupported device type: %d\n", ret);
588                 return ret;
589         }
590 
591         platform_set_drvdata(pdev, info);
592 
593         ret = s5m8767_rtc_init_reg(info);
594 
595         if (info->wtsr_smpl) {
596                 s5m_rtc_enable_wtsr(info, true);
597                 s5m_rtc_enable_smpl(info, true);
598         }
599 
600         device_init_wakeup(&pdev->dev, 1);
601 
602         info->rtc_dev = devm_rtc_device_register(&pdev->dev, "s5m-rtc",
603                                                  &s5m_rtc_ops, THIS_MODULE);
604 
605         if (IS_ERR(info->rtc_dev))
606                 return PTR_ERR(info->rtc_dev);
607 
608         ret = devm_request_threaded_irq(&pdev->dev, info->irq, NULL,
609                                         s5m_rtc_alarm_irq, 0, "rtc-alarm0",
610                                         info);
611         if (ret < 0)
612                 dev_err(&pdev->dev, "Failed to request alarm IRQ: %d: %d\n",
613                         info->irq, ret);
614 
615         return ret;
616 }
617 
618 static void s5m_rtc_shutdown(struct platform_device *pdev)
619 {
620         struct s5m_rtc_info *info = platform_get_drvdata(pdev);
621         int i;
622         unsigned int val = 0;
623         if (info->wtsr_smpl) {
624                 for (i = 0; i < 3; i++) {
625                         s5m_rtc_enable_wtsr(info, false);
626                         regmap_read(info->regmap, SEC_WTSR_SMPL_CNTL, &val);
627                         pr_debug("%s: WTSR_SMPL reg(0x%02x)\n", __func__, val);
628                         if (val & WTSR_ENABLE_MASK)
629                                 pr_emerg("%s: fail to disable WTSR\n",
630                                          __func__);
631                         else {
632                                 pr_info("%s: success to disable WTSR\n",
633                                         __func__);
634                                 break;
635                         }
636                 }
637         }
638         /* Disable SMPL when power off */
639         s5m_rtc_enable_smpl(info, false);
640 }
641 
642 #ifdef CONFIG_PM_SLEEP
643 static int s5m_rtc_resume(struct device *dev)
644 {
645         struct s5m_rtc_info *info = dev_get_drvdata(dev);
646         int ret = 0;
647 
648         if (device_may_wakeup(dev))
649                 ret = disable_irq_wake(info->irq);
650 
651         return ret;
652 }
653 
654 static int s5m_rtc_suspend(struct device *dev)
655 {
656         struct s5m_rtc_info *info = dev_get_drvdata(dev);
657         int ret = 0;
658 
659         if (device_may_wakeup(dev))
660                 ret = enable_irq_wake(info->irq);
661 
662         return ret;
663 }
664 #endif /* CONFIG_PM_SLEEP */
665 
666 static SIMPLE_DEV_PM_OPS(s5m_rtc_pm_ops, s5m_rtc_suspend, s5m_rtc_resume);
667 
668 static const struct platform_device_id s5m_rtc_id[] = {
669         { "s5m-rtc", 0 },
670 };
671 
672 static struct platform_driver s5m_rtc_driver = {
673         .driver         = {
674                 .name   = "s5m-rtc",
675                 .owner  = THIS_MODULE,
676                 .pm     = &s5m_rtc_pm_ops,
677         },
678         .probe          = s5m_rtc_probe,
679         .shutdown       = s5m_rtc_shutdown,
680         .id_table       = s5m_rtc_id,
681 };
682 
683 module_platform_driver(s5m_rtc_driver);
684 
685 /* Module information */
686 MODULE_AUTHOR("Sangbeom Kim <sbkim73@samsung.com>");
687 MODULE_DESCRIPTION("Samsung S5M RTC driver");
688 MODULE_LICENSE("GPL");
689 MODULE_ALIAS("platform:s5m-rtc");
690 

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