GNU Linux-libre 4.4.289-gnu1
[releases.git] / drivers / rtc / rtc-s5m.c
1 /*
2  * Copyright (c) 2013-2014 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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
19
20 #include <linux/module.h>
21 #include <linux/i2c.h>
22 #include <linux/bcd.h>
23 #include <linux/regmap.h>
24 #include <linux/rtc.h>
25 #include <linux/platform_device.h>
26 #include <linux/mfd/samsung/core.h>
27 #include <linux/mfd/samsung/irq.h>
28 #include <linux/mfd/samsung/rtc.h>
29 #include <linux/mfd/samsung/s2mps14.h>
30
31 /*
32  * Maximum number of retries for checking changes in UDR field
33  * of S5M_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 S5M_RTC_UDR_CON register. UDR is auto-cleared when data have
37  * been transferred.
38  */
39 #define UDR_READ_RETRY_CNT      5
40
41 /* Registers used by the driver which are different between chipsets. */
42 struct s5m_rtc_reg_config {
43         /* Number of registers used for setting time/alarm0/alarm1 */
44         unsigned int regs_count;
45         /* First register for time, seconds */
46         unsigned int time;
47         /* RTC control register */
48         unsigned int ctrl;
49         /* First register for alarm 0, seconds */
50         unsigned int alarm0;
51         /* First register for alarm 1, seconds */
52         unsigned int alarm1;
53         /*
54          * Register for update flag (UDR). Typically setting UDR field to 1
55          * will enable update of time or alarm register. Then it will be
56          * auto-cleared after successful update.
57          */
58         unsigned int rtc_udr_update;
59         /* Mask for UDR field in 'rtc_udr_update' register */
60         unsigned int rtc_udr_mask;
61 };
62
63 /* Register map for S5M8763 and S5M8767 */
64 static const struct s5m_rtc_reg_config s5m_rtc_regs = {
65         .regs_count             = 8,
66         .time                   = S5M_RTC_SEC,
67         .ctrl                   = S5M_ALARM1_CONF,
68         .alarm0                 = S5M_ALARM0_SEC,
69         .alarm1                 = S5M_ALARM1_SEC,
70         .rtc_udr_update         = S5M_RTC_UDR_CON,
71         .rtc_udr_mask           = S5M_RTC_UDR_MASK,
72 };
73
74 /*
75  * Register map for S2MPS14.
76  * It may be also suitable for S2MPS11 but this was not tested.
77  */
78 static const struct s5m_rtc_reg_config s2mps_rtc_regs = {
79         .regs_count             = 7,
80         .time                   = S2MPS_RTC_SEC,
81         .ctrl                   = S2MPS_RTC_CTRL,
82         .alarm0                 = S2MPS_ALARM0_SEC,
83         .alarm1                 = S2MPS_ALARM1_SEC,
84         .rtc_udr_update         = S2MPS_RTC_UDR_CON,
85         .rtc_udr_mask           = S2MPS_RTC_WUDR_MASK,
86 };
87
88 struct s5m_rtc_info {
89         struct device *dev;
90         struct i2c_client *i2c;
91         struct sec_pmic_dev *s5m87xx;
92         struct regmap *regmap;
93         struct rtc_device *rtc_dev;
94         int irq;
95         enum sec_device_type device_type;
96         int rtc_24hr_mode;
97         const struct s5m_rtc_reg_config *regs;
98 };
99
100 static const struct regmap_config s5m_rtc_regmap_config = {
101         .reg_bits = 8,
102         .val_bits = 8,
103
104         .max_register = S5M_RTC_REG_MAX,
105 };
106
107 static const struct regmap_config s2mps14_rtc_regmap_config = {
108         .reg_bits = 8,
109         .val_bits = 8,
110
111         .max_register = S2MPS_RTC_REG_MAX,
112 };
113
114 static void s5m8767_data_to_tm(u8 *data, struct rtc_time *tm,
115                                int rtc_24hr_mode)
116 {
117         tm->tm_sec = data[RTC_SEC] & 0x7f;
118         tm->tm_min = data[RTC_MIN] & 0x7f;
119         if (rtc_24hr_mode) {
120                 tm->tm_hour = data[RTC_HOUR] & 0x1f;
121         } else {
122                 tm->tm_hour = data[RTC_HOUR] & 0x0f;
123                 if (data[RTC_HOUR] & HOUR_PM_MASK)
124                         tm->tm_hour += 12;
125         }
126
127         tm->tm_wday = ffs(data[RTC_WEEKDAY] & 0x7f);
128         tm->tm_mday = data[RTC_DATE] & 0x1f;
129         tm->tm_mon = (data[RTC_MONTH] & 0x0f) - 1;
130         tm->tm_year = (data[RTC_YEAR1] & 0x7f) + 100;
131         tm->tm_yday = 0;
132         tm->tm_isdst = 0;
133 }
134
135 static int s5m8767_tm_to_data(struct rtc_time *tm, u8 *data)
136 {
137         data[RTC_SEC] = tm->tm_sec;
138         data[RTC_MIN] = tm->tm_min;
139
140         if (tm->tm_hour >= 12)
141                 data[RTC_HOUR] = tm->tm_hour | HOUR_PM_MASK;
142         else
143                 data[RTC_HOUR] = tm->tm_hour & ~HOUR_PM_MASK;
144
145         data[RTC_WEEKDAY] = 1 << tm->tm_wday;
146         data[RTC_DATE] = tm->tm_mday;
147         data[RTC_MONTH] = tm->tm_mon + 1;
148         data[RTC_YEAR1] = tm->tm_year > 100 ? (tm->tm_year - 100) : 0;
149
150         if (tm->tm_year < 100) {
151                 pr_err("RTC cannot handle the year %d\n",
152                        1900 + tm->tm_year);
153                 return -EINVAL;
154         } else {
155                 return 0;
156         }
157 }
158
159 /*
160  * Read RTC_UDR_CON register and wait till UDR field is cleared.
161  * This indicates that time/alarm update ended.
162  */
163 static inline int s5m8767_wait_for_udr_update(struct s5m_rtc_info *info)
164 {
165         int ret, retry = UDR_READ_RETRY_CNT;
166         unsigned int data;
167
168         do {
169                 ret = regmap_read(info->regmap, info->regs->rtc_udr_update,
170                                 &data);
171         } while (--retry && (data & info->regs->rtc_udr_mask) && !ret);
172
173         if (!retry)
174                 dev_err(info->dev, "waiting for UDR update, reached max number of retries\n");
175
176         return ret;
177 }
178
179 static inline int s5m_check_peding_alarm_interrupt(struct s5m_rtc_info *info,
180                 struct rtc_wkalrm *alarm)
181 {
182         int ret;
183         unsigned int val;
184
185         switch (info->device_type) {
186         case S5M8767X:
187         case S5M8763X:
188                 ret = regmap_read(info->regmap, S5M_RTC_STATUS, &val);
189                 val &= S5M_ALARM0_STATUS;
190                 break;
191         case S2MPS14X:
192         case S2MPS13X:
193                 ret = regmap_read(info->s5m87xx->regmap_pmic, S2MPS14_REG_ST2,
194                                 &val);
195                 val &= S2MPS_ALARM0_STATUS;
196                 break;
197         default:
198                 return -EINVAL;
199         }
200         if (ret < 0)
201                 return ret;
202
203         if (val)
204                 alarm->pending = 1;
205         else
206                 alarm->pending = 0;
207
208         return 0;
209 }
210
211 static inline int s5m8767_rtc_set_time_reg(struct s5m_rtc_info *info)
212 {
213         int ret;
214         unsigned int data;
215
216         ret = regmap_read(info->regmap, info->regs->rtc_udr_update, &data);
217         if (ret < 0) {
218                 dev_err(info->dev, "failed to read update reg(%d)\n", ret);
219                 return ret;
220         }
221
222         data |= info->regs->rtc_udr_mask;
223         if (info->device_type == S5M8763X || info->device_type == S5M8767X)
224                 data |= S5M_RTC_TIME_EN_MASK;
225
226         ret = regmap_write(info->regmap, info->regs->rtc_udr_update, data);
227         if (ret < 0) {
228                 dev_err(info->dev, "failed to write update reg(%d)\n", ret);
229                 return ret;
230         }
231
232         ret = s5m8767_wait_for_udr_update(info);
233
234         return ret;
235 }
236
237 static inline int s5m8767_rtc_set_alarm_reg(struct s5m_rtc_info *info)
238 {
239         int ret;
240         unsigned int data;
241
242         ret = regmap_read(info->regmap, info->regs->rtc_udr_update, &data);
243         if (ret < 0) {
244                 dev_err(info->dev, "%s: fail to read update reg(%d)\n",
245                         __func__, ret);
246                 return ret;
247         }
248
249         data |= info->regs->rtc_udr_mask;
250         switch (info->device_type) {
251         case S5M8763X:
252         case S5M8767X:
253                 data &= ~S5M_RTC_TIME_EN_MASK;
254                 break;
255         case S2MPS14X:
256                 data |= S2MPS_RTC_RUDR_MASK;
257                 break;
258         case S2MPS13X:
259                 data |= S2MPS13_RTC_AUDR_MASK;
260                 break;
261         default:
262                 return -EINVAL;
263         }
264
265         ret = regmap_write(info->regmap, info->regs->rtc_udr_update, data);
266         if (ret < 0) {
267                 dev_err(info->dev, "%s: fail to write update reg(%d)\n",
268                         __func__, ret);
269                 return ret;
270         }
271
272         ret = s5m8767_wait_for_udr_update(info);
273
274         /* On S2MPS13 the AUDR is not auto-cleared */
275         if (info->device_type == S2MPS13X)
276                 regmap_update_bits(info->regmap, info->regs->rtc_udr_update,
277                                    S2MPS13_RTC_AUDR_MASK, 0);
278
279         return ret;
280 }
281
282 static void s5m8763_data_to_tm(u8 *data, struct rtc_time *tm)
283 {
284         tm->tm_sec = bcd2bin(data[RTC_SEC]);
285         tm->tm_min = bcd2bin(data[RTC_MIN]);
286
287         if (data[RTC_HOUR] & HOUR_12) {
288                 tm->tm_hour = bcd2bin(data[RTC_HOUR] & 0x1f);
289                 if (data[RTC_HOUR] & HOUR_PM)
290                         tm->tm_hour += 12;
291         } else {
292                 tm->tm_hour = bcd2bin(data[RTC_HOUR] & 0x3f);
293         }
294
295         tm->tm_wday = data[RTC_WEEKDAY] & 0x07;
296         tm->tm_mday = bcd2bin(data[RTC_DATE]);
297         tm->tm_mon = bcd2bin(data[RTC_MONTH]);
298         tm->tm_year = bcd2bin(data[RTC_YEAR1]) + bcd2bin(data[RTC_YEAR2]) * 100;
299         tm->tm_year -= 1900;
300 }
301
302 static void s5m8763_tm_to_data(struct rtc_time *tm, u8 *data)
303 {
304         data[RTC_SEC] = bin2bcd(tm->tm_sec);
305         data[RTC_MIN] = bin2bcd(tm->tm_min);
306         data[RTC_HOUR] = bin2bcd(tm->tm_hour);
307         data[RTC_WEEKDAY] = tm->tm_wday;
308         data[RTC_DATE] = bin2bcd(tm->tm_mday);
309         data[RTC_MONTH] = bin2bcd(tm->tm_mon);
310         data[RTC_YEAR1] = bin2bcd(tm->tm_year % 100);
311         data[RTC_YEAR2] = bin2bcd((tm->tm_year + 1900) / 100);
312 }
313
314 static int s5m_rtc_read_time(struct device *dev, struct rtc_time *tm)
315 {
316         struct s5m_rtc_info *info = dev_get_drvdata(dev);
317         u8 data[info->regs->regs_count];
318         int ret;
319
320         if (info->device_type == S2MPS14X || info->device_type == S2MPS13X) {
321                 ret = regmap_update_bits(info->regmap,
322                                 info->regs->rtc_udr_update,
323                                 S2MPS_RTC_RUDR_MASK, S2MPS_RTC_RUDR_MASK);
324                 if (ret) {
325                         dev_err(dev,
326                                 "Failed to prepare registers for time reading: %d\n",
327                                 ret);
328                         return ret;
329                 }
330         }
331         ret = regmap_bulk_read(info->regmap, info->regs->time, data,
332                         info->regs->regs_count);
333         if (ret < 0)
334                 return ret;
335
336         switch (info->device_type) {
337         case S5M8763X:
338                 s5m8763_data_to_tm(data, tm);
339                 break;
340
341         case S5M8767X:
342         case S2MPS14X:
343         case S2MPS13X:
344                 s5m8767_data_to_tm(data, tm, info->rtc_24hr_mode);
345                 break;
346
347         default:
348                 return -EINVAL;
349         }
350
351         dev_dbg(dev, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__,
352                 1900 + tm->tm_year, 1 + tm->tm_mon, tm->tm_mday,
353                 tm->tm_hour, tm->tm_min, tm->tm_sec, tm->tm_wday);
354
355         return rtc_valid_tm(tm);
356 }
357
358 static int s5m_rtc_set_time(struct device *dev, struct rtc_time *tm)
359 {
360         struct s5m_rtc_info *info = dev_get_drvdata(dev);
361         u8 data[info->regs->regs_count];
362         int ret = 0;
363
364         switch (info->device_type) {
365         case S5M8763X:
366                 s5m8763_tm_to_data(tm, data);
367                 break;
368         case S5M8767X:
369         case S2MPS14X:
370         case S2MPS13X:
371                 ret = s5m8767_tm_to_data(tm, data);
372                 break;
373         default:
374                 return -EINVAL;
375         }
376
377         if (ret < 0)
378                 return ret;
379
380         dev_dbg(dev, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__,
381                 1900 + tm->tm_year, 1 + tm->tm_mon, tm->tm_mday,
382                 tm->tm_hour, tm->tm_min, tm->tm_sec, tm->tm_wday);
383
384         ret = regmap_raw_write(info->regmap, info->regs->time, data,
385                         info->regs->regs_count);
386         if (ret < 0)
387                 return ret;
388
389         ret = s5m8767_rtc_set_time_reg(info);
390
391         return ret;
392 }
393
394 static int s5m_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
395 {
396         struct s5m_rtc_info *info = dev_get_drvdata(dev);
397         u8 data[info->regs->regs_count];
398         unsigned int val;
399         int ret, i;
400
401         ret = regmap_bulk_read(info->regmap, info->regs->alarm0, data,
402                         info->regs->regs_count);
403         if (ret < 0)
404                 return ret;
405
406         switch (info->device_type) {
407         case S5M8763X:
408                 s5m8763_data_to_tm(data, &alrm->time);
409                 ret = regmap_read(info->regmap, S5M_ALARM0_CONF, &val);
410                 if (ret < 0)
411                         return ret;
412
413                 alrm->enabled = !!val;
414                 break;
415
416         case S5M8767X:
417         case S2MPS14X:
418         case S2MPS13X:
419                 s5m8767_data_to_tm(data, &alrm->time, info->rtc_24hr_mode);
420                 alrm->enabled = 0;
421                 for (i = 0; i < info->regs->regs_count; i++) {
422                         if (data[i] & ALARM_ENABLE_MASK) {
423                                 alrm->enabled = 1;
424                                 break;
425                         }
426                 }
427                 break;
428
429         default:
430                 return -EINVAL;
431         }
432
433         dev_dbg(dev, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__,
434                 1900 + alrm->time.tm_year, 1 + alrm->time.tm_mon,
435                 alrm->time.tm_mday, alrm->time.tm_hour,
436                 alrm->time.tm_min, alrm->time.tm_sec,
437                 alrm->time.tm_wday);
438
439         ret = s5m_check_peding_alarm_interrupt(info, alrm);
440
441         return 0;
442 }
443
444 static int s5m_rtc_stop_alarm(struct s5m_rtc_info *info)
445 {
446         u8 data[info->regs->regs_count];
447         int ret, i;
448         struct rtc_time tm;
449
450         ret = regmap_bulk_read(info->regmap, info->regs->alarm0, data,
451                         info->regs->regs_count);
452         if (ret < 0)
453                 return ret;
454
455         s5m8767_data_to_tm(data, &tm, info->rtc_24hr_mode);
456         dev_dbg(info->dev, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__,
457                 1900 + tm.tm_year, 1 + tm.tm_mon, tm.tm_mday,
458                 tm.tm_hour, tm.tm_min, tm.tm_sec, tm.tm_wday);
459
460         switch (info->device_type) {
461         case S5M8763X:
462                 ret = regmap_write(info->regmap, S5M_ALARM0_CONF, 0);
463                 break;
464
465         case S5M8767X:
466         case S2MPS14X:
467         case S2MPS13X:
468                 for (i = 0; i < info->regs->regs_count; i++)
469                         data[i] &= ~ALARM_ENABLE_MASK;
470
471                 ret = regmap_raw_write(info->regmap, info->regs->alarm0, data,
472                                 info->regs->regs_count);
473                 if (ret < 0)
474                         return ret;
475
476                 ret = s5m8767_rtc_set_alarm_reg(info);
477
478                 break;
479
480         default:
481                 return -EINVAL;
482         }
483
484         return ret;
485 }
486
487 static int s5m_rtc_start_alarm(struct s5m_rtc_info *info)
488 {
489         int ret;
490         u8 data[info->regs->regs_count];
491         u8 alarm0_conf;
492         struct rtc_time tm;
493
494         ret = regmap_bulk_read(info->regmap, info->regs->alarm0, data,
495                         info->regs->regs_count);
496         if (ret < 0)
497                 return ret;
498
499         s5m8767_data_to_tm(data, &tm, info->rtc_24hr_mode);
500         dev_dbg(info->dev, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__,
501                 1900 + tm.tm_year, 1 + tm.tm_mon, tm.tm_mday,
502                 tm.tm_hour, tm.tm_min, tm.tm_sec, tm.tm_wday);
503
504         switch (info->device_type) {
505         case S5M8763X:
506                 alarm0_conf = 0x77;
507                 ret = regmap_write(info->regmap, S5M_ALARM0_CONF, alarm0_conf);
508                 break;
509
510         case S5M8767X:
511         case S2MPS14X:
512         case S2MPS13X:
513                 data[RTC_SEC] |= ALARM_ENABLE_MASK;
514                 data[RTC_MIN] |= ALARM_ENABLE_MASK;
515                 data[RTC_HOUR] |= ALARM_ENABLE_MASK;
516                 data[RTC_WEEKDAY] &= ~ALARM_ENABLE_MASK;
517                 if (data[RTC_DATE] & 0x1f)
518                         data[RTC_DATE] |= ALARM_ENABLE_MASK;
519                 if (data[RTC_MONTH] & 0xf)
520                         data[RTC_MONTH] |= ALARM_ENABLE_MASK;
521                 if (data[RTC_YEAR1] & 0x7f)
522                         data[RTC_YEAR1] |= ALARM_ENABLE_MASK;
523
524                 ret = regmap_raw_write(info->regmap, info->regs->alarm0, data,
525                                 info->regs->regs_count);
526                 if (ret < 0)
527                         return ret;
528                 ret = s5m8767_rtc_set_alarm_reg(info);
529
530                 break;
531
532         default:
533                 return -EINVAL;
534         }
535
536         return ret;
537 }
538
539 static int s5m_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
540 {
541         struct s5m_rtc_info *info = dev_get_drvdata(dev);
542         u8 data[info->regs->regs_count];
543         int ret;
544
545         switch (info->device_type) {
546         case S5M8763X:
547                 s5m8763_tm_to_data(&alrm->time, data);
548                 break;
549
550         case S5M8767X:
551         case S2MPS14X:
552         case S2MPS13X:
553                 s5m8767_tm_to_data(&alrm->time, data);
554                 break;
555
556         default:
557                 return -EINVAL;
558         }
559
560         dev_dbg(dev, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__,
561                 1900 + alrm->time.tm_year, 1 + alrm->time.tm_mon,
562                 alrm->time.tm_mday, alrm->time.tm_hour, alrm->time.tm_min,
563                 alrm->time.tm_sec, alrm->time.tm_wday);
564
565         ret = s5m_rtc_stop_alarm(info);
566         if (ret < 0)
567                 return ret;
568
569         ret = regmap_raw_write(info->regmap, info->regs->alarm0, data,
570                         info->regs->regs_count);
571         if (ret < 0)
572                 return ret;
573
574         ret = s5m8767_rtc_set_alarm_reg(info);
575         if (ret < 0)
576                 return ret;
577
578         if (alrm->enabled)
579                 ret = s5m_rtc_start_alarm(info);
580
581         return ret;
582 }
583
584 static int s5m_rtc_alarm_irq_enable(struct device *dev,
585                                     unsigned int enabled)
586 {
587         struct s5m_rtc_info *info = dev_get_drvdata(dev);
588
589         if (enabled)
590                 return s5m_rtc_start_alarm(info);
591         else
592                 return s5m_rtc_stop_alarm(info);
593 }
594
595 static irqreturn_t s5m_rtc_alarm_irq(int irq, void *data)
596 {
597         struct s5m_rtc_info *info = data;
598
599         rtc_update_irq(info->rtc_dev, 1, RTC_IRQF | RTC_AF);
600
601         return IRQ_HANDLED;
602 }
603
604 static const struct rtc_class_ops s5m_rtc_ops = {
605         .read_time = s5m_rtc_read_time,
606         .set_time = s5m_rtc_set_time,
607         .read_alarm = s5m_rtc_read_alarm,
608         .set_alarm = s5m_rtc_set_alarm,
609         .alarm_irq_enable = s5m_rtc_alarm_irq_enable,
610 };
611
612 static int s5m8767_rtc_init_reg(struct s5m_rtc_info *info)
613 {
614         u8 data[2];
615         int ret;
616
617         switch (info->device_type) {
618         case S5M8763X:
619         case S5M8767X:
620                 /* UDR update time. Default of 7.32 ms is too long. */
621                 ret = regmap_update_bits(info->regmap, S5M_RTC_UDR_CON,
622                                 S5M_RTC_UDR_T_MASK, S5M_RTC_UDR_T_450_US);
623                 if (ret < 0)
624                         dev_err(info->dev, "%s: fail to change UDR time: %d\n",
625                                         __func__, ret);
626
627                 /* Set RTC control register : Binary mode, 24hour mode */
628                 data[0] = (1 << BCD_EN_SHIFT) | (1 << MODEL24_SHIFT);
629                 data[1] = (0 << BCD_EN_SHIFT) | (1 << MODEL24_SHIFT);
630
631                 ret = regmap_raw_write(info->regmap, S5M_ALARM0_CONF, data, 2);
632                 break;
633
634         case S2MPS14X:
635         case S2MPS13X:
636                 data[0] = (0 << BCD_EN_SHIFT) | (1 << MODEL24_SHIFT);
637                 ret = regmap_write(info->regmap, info->regs->ctrl, data[0]);
638                 if (ret < 0)
639                         break;
640
641                 /*
642                  * Should set WUDR & (RUDR or AUDR) bits to high after writing
643                  * RTC_CTRL register like writing Alarm registers. We can't find
644                  * the description from datasheet but vendor code does that
645                  * really.
646                  */
647                 ret = s5m8767_rtc_set_alarm_reg(info);
648                 break;
649
650         default:
651                 return -EINVAL;
652         }
653
654         info->rtc_24hr_mode = 1;
655         if (ret < 0) {
656                 dev_err(info->dev, "%s: fail to write controlm reg(%d)\n",
657                         __func__, ret);
658                 return ret;
659         }
660
661         return ret;
662 }
663
664 static int s5m_rtc_probe(struct platform_device *pdev)
665 {
666         struct sec_pmic_dev *s5m87xx = dev_get_drvdata(pdev->dev.parent);
667         struct sec_platform_data *pdata = s5m87xx->pdata;
668         struct s5m_rtc_info *info;
669         const struct regmap_config *regmap_cfg;
670         int ret, alarm_irq;
671
672         if (!pdata) {
673                 dev_err(pdev->dev.parent, "Platform data not supplied\n");
674                 return -ENODEV;
675         }
676
677         info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
678         if (!info)
679                 return -ENOMEM;
680
681         switch (platform_get_device_id(pdev)->driver_data) {
682         case S2MPS14X:
683         case S2MPS13X:
684                 regmap_cfg = &s2mps14_rtc_regmap_config;
685                 info->regs = &s2mps_rtc_regs;
686                 alarm_irq = S2MPS14_IRQ_RTCA0;
687                 break;
688         case S5M8763X:
689                 regmap_cfg = &s5m_rtc_regmap_config;
690                 info->regs = &s5m_rtc_regs;
691                 alarm_irq = S5M8763_IRQ_ALARM0;
692                 break;
693         case S5M8767X:
694                 regmap_cfg = &s5m_rtc_regmap_config;
695                 info->regs = &s5m_rtc_regs;
696                 alarm_irq = S5M8767_IRQ_RTCA1;
697                 break;
698         default:
699                 dev_err(&pdev->dev,
700                                 "Device type %lu is not supported by RTC driver\n",
701                                 platform_get_device_id(pdev)->driver_data);
702                 return -ENODEV;
703         }
704
705         info->i2c = i2c_new_dummy(s5m87xx->i2c->adapter, RTC_I2C_ADDR);
706         if (!info->i2c) {
707                 dev_err(&pdev->dev, "Failed to allocate I2C for RTC\n");
708                 return -ENODEV;
709         }
710
711         info->regmap = devm_regmap_init_i2c(info->i2c, regmap_cfg);
712         if (IS_ERR(info->regmap)) {
713                 ret = PTR_ERR(info->regmap);
714                 dev_err(&pdev->dev, "Failed to allocate RTC register map: %d\n",
715                                 ret);
716                 goto err;
717         }
718
719         info->dev = &pdev->dev;
720         info->s5m87xx = s5m87xx;
721         info->device_type = platform_get_device_id(pdev)->driver_data;
722
723         if (s5m87xx->irq_data) {
724                 info->irq = regmap_irq_get_virq(s5m87xx->irq_data, alarm_irq);
725                 if (info->irq <= 0) {
726                         ret = -EINVAL;
727                         dev_err(&pdev->dev, "Failed to get virtual IRQ %d\n",
728                                 alarm_irq);
729                         goto err;
730                 }
731         }
732
733         platform_set_drvdata(pdev, info);
734
735         ret = s5m8767_rtc_init_reg(info);
736
737         device_init_wakeup(&pdev->dev, 1);
738
739         info->rtc_dev = devm_rtc_device_register(&pdev->dev, "s5m-rtc",
740                                                  &s5m_rtc_ops, THIS_MODULE);
741
742         if (IS_ERR(info->rtc_dev)) {
743                 ret = PTR_ERR(info->rtc_dev);
744                 goto err;
745         }
746
747         if (!info->irq) {
748                 dev_info(&pdev->dev, "Alarm IRQ not available\n");
749                 return 0;
750         }
751
752         ret = devm_request_threaded_irq(&pdev->dev, info->irq, NULL,
753                                         s5m_rtc_alarm_irq, 0, "rtc-alarm0",
754                                         info);
755         if (ret < 0) {
756                 dev_err(&pdev->dev, "Failed to request alarm IRQ: %d: %d\n",
757                         info->irq, ret);
758                 goto err;
759         }
760
761         return 0;
762
763 err:
764         i2c_unregister_device(info->i2c);
765
766         return ret;
767 }
768
769 static int s5m_rtc_remove(struct platform_device *pdev)
770 {
771         struct s5m_rtc_info *info = platform_get_drvdata(pdev);
772
773         i2c_unregister_device(info->i2c);
774
775         return 0;
776 }
777
778 #ifdef CONFIG_PM_SLEEP
779 static int s5m_rtc_resume(struct device *dev)
780 {
781         struct s5m_rtc_info *info = dev_get_drvdata(dev);
782         int ret = 0;
783
784         if (info->irq && device_may_wakeup(dev))
785                 ret = disable_irq_wake(info->irq);
786
787         return ret;
788 }
789
790 static int s5m_rtc_suspend(struct device *dev)
791 {
792         struct s5m_rtc_info *info = dev_get_drvdata(dev);
793         int ret = 0;
794
795         if (info->irq && device_may_wakeup(dev))
796                 ret = enable_irq_wake(info->irq);
797
798         return ret;
799 }
800 #endif /* CONFIG_PM_SLEEP */
801
802 static SIMPLE_DEV_PM_OPS(s5m_rtc_pm_ops, s5m_rtc_suspend, s5m_rtc_resume);
803
804 static const struct platform_device_id s5m_rtc_id[] = {
805         { "s5m-rtc",            S5M8767X },
806         { "s2mps13-rtc",        S2MPS13X },
807         { "s2mps14-rtc",        S2MPS14X },
808         { },
809 };
810 MODULE_DEVICE_TABLE(platform, s5m_rtc_id);
811
812 static struct platform_driver s5m_rtc_driver = {
813         .driver         = {
814                 .name   = "s5m-rtc",
815                 .pm     = &s5m_rtc_pm_ops,
816         },
817         .probe          = s5m_rtc_probe,
818         .remove         = s5m_rtc_remove,
819         .id_table       = s5m_rtc_id,
820 };
821
822 module_platform_driver(s5m_rtc_driver);
823
824 /* Module information */
825 MODULE_AUTHOR("Sangbeom Kim <sbkim73@samsung.com>");
826 MODULE_DESCRIPTION("Samsung S5M/S2MPS14 RTC driver");
827 MODULE_LICENSE("GPL");
828 MODULE_ALIAS("platform:s5m-rtc");