Version:  2.0.40 2.2.26 2.4.37 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7

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

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