Version:  2.0.40 2.2.26 2.4.37 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 3.19 4.0 4.1

Linux/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                 break;
639 
640         default:
641                 return -EINVAL;
642         }
643 
644         info->rtc_24hr_mode = 1;
645         if (ret < 0) {
646                 dev_err(info->dev, "%s: fail to write controlm reg(%d)\n",
647                         __func__, ret);
648                 return ret;
649         }
650 
651         return ret;
652 }
653 
654 static int s5m_rtc_probe(struct platform_device *pdev)
655 {
656         struct sec_pmic_dev *s5m87xx = dev_get_drvdata(pdev->dev.parent);
657         struct sec_platform_data *pdata = s5m87xx->pdata;
658         struct s5m_rtc_info *info;
659         const struct regmap_config *regmap_cfg;
660         int ret, alarm_irq;
661 
662         if (!pdata) {
663                 dev_err(pdev->dev.parent, "Platform data not supplied\n");
664                 return -ENODEV;
665         }
666 
667         info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
668         if (!info)
669                 return -ENOMEM;
670 
671         switch (platform_get_device_id(pdev)->driver_data) {
672         case S2MPS14X:
673         case S2MPS13X:
674                 regmap_cfg = &s2mps14_rtc_regmap_config;
675                 info->regs = &s2mps_rtc_regs;
676                 alarm_irq = S2MPS14_IRQ_RTCA0;
677                 break;
678         case S5M8763X:
679                 regmap_cfg = &s5m_rtc_regmap_config;
680                 info->regs = &s5m_rtc_regs;
681                 alarm_irq = S5M8763_IRQ_ALARM0;
682                 break;
683         case S5M8767X:
684                 regmap_cfg = &s5m_rtc_regmap_config;
685                 info->regs = &s5m_rtc_regs;
686                 alarm_irq = S5M8767_IRQ_RTCA1;
687                 break;
688         default:
689                 dev_err(&pdev->dev,
690                                 "Device type %lu is not supported by RTC driver\n",
691                                 platform_get_device_id(pdev)->driver_data);
692                 return -ENODEV;
693         }
694 
695         info->i2c = i2c_new_dummy(s5m87xx->i2c->adapter, RTC_I2C_ADDR);
696         if (!info->i2c) {
697                 dev_err(&pdev->dev, "Failed to allocate I2C for RTC\n");
698                 return -ENODEV;
699         }
700 
701         info->regmap = devm_regmap_init_i2c(info->i2c, regmap_cfg);
702         if (IS_ERR(info->regmap)) {
703                 ret = PTR_ERR(info->regmap);
704                 dev_err(&pdev->dev, "Failed to allocate RTC register map: %d\n",
705                                 ret);
706                 goto err;
707         }
708 
709         info->dev = &pdev->dev;
710         info->s5m87xx = s5m87xx;
711         info->device_type = platform_get_device_id(pdev)->driver_data;
712 
713         if (s5m87xx->irq_data) {
714                 info->irq = regmap_irq_get_virq(s5m87xx->irq_data, alarm_irq);
715                 if (info->irq <= 0) {
716                         ret = -EINVAL;
717                         dev_err(&pdev->dev, "Failed to get virtual IRQ %d\n",
718                                 alarm_irq);
719                         goto err;
720                 }
721         }
722 
723         platform_set_drvdata(pdev, info);
724 
725         ret = s5m8767_rtc_init_reg(info);
726 
727         device_init_wakeup(&pdev->dev, 1);
728 
729         info->rtc_dev = devm_rtc_device_register(&pdev->dev, "s5m-rtc",
730                                                  &s5m_rtc_ops, THIS_MODULE);
731 
732         if (IS_ERR(info->rtc_dev)) {
733                 ret = PTR_ERR(info->rtc_dev);
734                 goto err;
735         }
736 
737         if (!info->irq) {
738                 dev_info(&pdev->dev, "Alarm IRQ not available\n");
739                 return 0;
740         }
741 
742         ret = devm_request_threaded_irq(&pdev->dev, info->irq, NULL,
743                                         s5m_rtc_alarm_irq, 0, "rtc-alarm0",
744                                         info);
745         if (ret < 0) {
746                 dev_err(&pdev->dev, "Failed to request alarm IRQ: %d: %d\n",
747                         info->irq, ret);
748                 goto err;
749         }
750 
751         return 0;
752 
753 err:
754         i2c_unregister_device(info->i2c);
755 
756         return ret;
757 }
758 
759 static int s5m_rtc_remove(struct platform_device *pdev)
760 {
761         struct s5m_rtc_info *info = platform_get_drvdata(pdev);
762 
763         i2c_unregister_device(info->i2c);
764 
765         return 0;
766 }
767 
768 #ifdef CONFIG_PM_SLEEP
769 static int s5m_rtc_resume(struct device *dev)
770 {
771         struct s5m_rtc_info *info = dev_get_drvdata(dev);
772         int ret = 0;
773 
774         if (info->irq && device_may_wakeup(dev))
775                 ret = disable_irq_wake(info->irq);
776 
777         return ret;
778 }
779 
780 static int s5m_rtc_suspend(struct device *dev)
781 {
782         struct s5m_rtc_info *info = dev_get_drvdata(dev);
783         int ret = 0;
784 
785         if (info->irq && device_may_wakeup(dev))
786                 ret = enable_irq_wake(info->irq);
787 
788         return ret;
789 }
790 #endif /* CONFIG_PM_SLEEP */
791 
792 static SIMPLE_DEV_PM_OPS(s5m_rtc_pm_ops, s5m_rtc_suspend, s5m_rtc_resume);
793 
794 static const struct platform_device_id s5m_rtc_id[] = {
795         { "s5m-rtc",            S5M8767X },
796         { "s2mps13-rtc",        S2MPS13X },
797         { "s2mps14-rtc",        S2MPS14X },
798         { },
799 };
800 
801 static struct platform_driver s5m_rtc_driver = {
802         .driver         = {
803                 .name   = "s5m-rtc",
804                 .pm     = &s5m_rtc_pm_ops,
805         },
806         .probe          = s5m_rtc_probe,
807         .remove         = s5m_rtc_remove,
808         .id_table       = s5m_rtc_id,
809 };
810 
811 module_platform_driver(s5m_rtc_driver);
812 
813 /* Module information */
814 MODULE_AUTHOR("Sangbeom Kim <sbkim73@samsung.com>");
815 MODULE_DESCRIPTION("Samsung S5M/S2MPS14 RTC driver");
816 MODULE_LICENSE("GPL");
817 MODULE_ALIAS("platform:s5m-rtc");
818 

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