LCOV - code coverage report
Current view: top level - drivers/rtc - interface.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 106 455 23.3 %
Date: 2022-04-01 14:17:54 Functions: 7 32 21.9 %
Branches: 32 240 13.3 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : /*
       3                 :            :  * RTC subsystem, interface functions
       4                 :            :  *
       5                 :            :  * Copyright (C) 2005 Tower Technologies
       6                 :            :  * Author: Alessandro Zummo <a.zummo@towertech.it>
       7                 :            :  *
       8                 :            :  * based on arch/arm/common/rtctime.c
       9                 :            :  */
      10                 :            : 
      11                 :            : #include <linux/rtc.h>
      12                 :            : #include <linux/sched.h>
      13                 :            : #include <linux/module.h>
      14                 :            : #include <linux/log2.h>
      15                 :            : #include <linux/workqueue.h>
      16                 :            : 
      17                 :            : #define CREATE_TRACE_POINTS
      18                 :            : #include <trace/events/rtc.h>
      19                 :            : 
      20                 :            : static int rtc_timer_enqueue(struct rtc_device *rtc, struct rtc_timer *timer);
      21                 :            : static void rtc_timer_remove(struct rtc_device *rtc, struct rtc_timer *timer);
      22                 :            : 
      23                 :         33 : static void rtc_add_offset(struct rtc_device *rtc, struct rtc_time *tm)
      24                 :            : {
      25                 :         33 :         time64_t secs;
      26                 :            : 
      27         [ -  + ]:         33 :         if (!rtc->offset_secs)
      28                 :            :                 return;
      29                 :            : 
      30                 :          0 :         secs = rtc_tm_to_time64(tm);
      31                 :            : 
      32                 :            :         /*
      33                 :            :          * Since the reading time values from RTC device are always in the RTC
      34                 :            :          * original valid range, but we need to skip the overlapped region
      35                 :            :          * between expanded range and original range, which is no need to add
      36                 :            :          * the offset.
      37                 :            :          */
      38   [ #  #  #  #  :          0 :         if ((rtc->start_secs > rtc->range_min && secs >= rtc->start_secs) ||
                   #  # ]
      39                 :          0 :             (rtc->start_secs < rtc->range_min &&
      40         [ #  # ]:          0 :              secs <= (rtc->start_secs + rtc->range_max - rtc->range_min)))
      41                 :            :                 return;
      42                 :            : 
      43                 :          0 :         rtc_time64_to_tm(secs + rtc->offset_secs, tm);
      44                 :            : }
      45                 :            : 
      46                 :          0 : static void rtc_subtract_offset(struct rtc_device *rtc, struct rtc_time *tm)
      47                 :            : {
      48                 :          0 :         time64_t secs;
      49                 :            : 
      50         [ #  # ]:          0 :         if (!rtc->offset_secs)
      51                 :            :                 return;
      52                 :            : 
      53                 :          0 :         secs = rtc_tm_to_time64(tm);
      54                 :            : 
      55                 :            :         /*
      56                 :            :          * If the setting time values are in the valid range of RTC hardware
      57                 :            :          * device, then no need to subtract the offset when setting time to RTC
      58                 :            :          * device. Otherwise we need to subtract the offset to make the time
      59                 :            :          * values are valid for RTC hardware device.
      60                 :            :          */
      61   [ #  #  #  # ]:          0 :         if (secs >= rtc->range_min && secs <= rtc->range_max)
      62                 :            :                 return;
      63                 :            : 
      64                 :          0 :         rtc_time64_to_tm(secs - rtc->offset_secs, tm);
      65                 :            : }
      66                 :            : 
      67                 :          0 : static int rtc_valid_range(struct rtc_device *rtc, struct rtc_time *tm)
      68                 :            : {
      69         [ #  # ]:          0 :         if (rtc->range_min != rtc->range_max) {
      70                 :          0 :                 time64_t time = rtc_tm_to_time64(tm);
      71         [ #  # ]:          0 :                 time64_t range_min = rtc->set_start_time ? rtc->start_secs :
      72                 :            :                         rtc->range_min;
      73                 :          0 :                 timeu64_t range_max = rtc->set_start_time ?
      74         [ #  # ]:          0 :                         (rtc->start_secs + rtc->range_max - rtc->range_min) :
      75                 :            :                         rtc->range_max;
      76                 :            : 
      77         [ #  # ]:          0 :                 if (time < range_min || time > range_max)
      78                 :          0 :                         return -ERANGE;
      79                 :            :         }
      80                 :            : 
      81                 :            :         return 0;
      82                 :            : }
      83                 :            : 
      84                 :         33 : static int __rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm)
      85                 :            : {
      86                 :         33 :         int err;
      87                 :            : 
      88         [ +  - ]:         33 :         if (!rtc->ops) {
      89                 :            :                 err = -ENODEV;
      90         [ +  - ]:         33 :         } else if (!rtc->ops->read_time) {
      91                 :            :                 err = -EINVAL;
      92                 :            :         } else {
      93                 :         33 :                 memset(tm, 0, sizeof(struct rtc_time));
      94                 :         33 :                 err = rtc->ops->read_time(rtc->dev.parent, tm);
      95         [ +  - ]:         33 :                 if (err < 0) {
      96                 :            :                         dev_dbg(&rtc->dev, "read_time: fail to read: %d\n",
      97                 :            :                                 err);
      98                 :            :                         return err;
      99                 :            :                 }
     100                 :            : 
     101                 :         33 :                 rtc_add_offset(rtc, tm);
     102                 :            : 
     103                 :         33 :                 err = rtc_valid_tm(tm);
     104                 :         33 :                 if (err < 0)
     105                 :            :                         dev_dbg(&rtc->dev, "read_time: rtc_time isn't valid\n");
     106                 :            :         }
     107                 :            :         return err;
     108                 :            : }
     109                 :            : 
     110                 :         33 : int rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm)
     111                 :            : {
     112                 :         33 :         int err;
     113                 :            : 
     114                 :         33 :         err = mutex_lock_interruptible(&rtc->ops_lock);
     115         [ +  - ]:         33 :         if (err)
     116                 :            :                 return err;
     117                 :            : 
     118                 :         33 :         err = __rtc_read_time(rtc, tm);
     119                 :         33 :         mutex_unlock(&rtc->ops_lock);
     120                 :            : 
     121                 :         33 :         trace_rtc_read_time(rtc_tm_to_time64(tm), err);
     122                 :         33 :         return err;
     123                 :            : }
     124                 :            : EXPORT_SYMBOL_GPL(rtc_read_time);
     125                 :            : 
     126                 :          0 : int rtc_set_time(struct rtc_device *rtc, struct rtc_time *tm)
     127                 :            : {
     128                 :          0 :         int err, uie;
     129                 :            : 
     130                 :          0 :         err = rtc_valid_tm(tm);
     131         [ #  # ]:          0 :         if (err != 0)
     132                 :            :                 return err;
     133                 :            : 
     134                 :          0 :         err = rtc_valid_range(rtc, tm);
     135         [ #  # ]:          0 :         if (err)
     136                 :            :                 return err;
     137                 :            : 
     138                 :          0 :         rtc_subtract_offset(rtc, tm);
     139                 :            : 
     140                 :            : #ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
     141                 :            :         uie = rtc->uie_rtctimer.enabled || rtc->uie_irq_active;
     142                 :            : #else
     143                 :          0 :         uie = rtc->uie_rtctimer.enabled;
     144                 :            : #endif
     145         [ #  # ]:          0 :         if (uie) {
     146                 :          0 :                 err = rtc_update_irq_enable(rtc, 0);
     147         [ #  # ]:          0 :                 if (err)
     148                 :            :                         return err;
     149                 :            :         }
     150                 :            : 
     151                 :          0 :         err = mutex_lock_interruptible(&rtc->ops_lock);
     152         [ #  # ]:          0 :         if (err)
     153                 :            :                 return err;
     154                 :            : 
     155         [ #  # ]:          0 :         if (!rtc->ops)
     156                 :            :                 err = -ENODEV;
     157         [ #  # ]:          0 :         else if (rtc->ops->set_time)
     158                 :          0 :                 err = rtc->ops->set_time(rtc->dev.parent, tm);
     159                 :            :         else
     160                 :            :                 err = -EINVAL;
     161                 :            : 
     162                 :          0 :         pm_stay_awake(rtc->dev.parent);
     163                 :          0 :         mutex_unlock(&rtc->ops_lock);
     164                 :            :         /* A timer might have just expired */
     165                 :          0 :         schedule_work(&rtc->irqwork);
     166                 :            : 
     167         [ #  # ]:          0 :         if (uie) {
     168                 :          0 :                 err = rtc_update_irq_enable(rtc, 1);
     169         [ #  # ]:          0 :                 if (err)
     170                 :            :                         return err;
     171                 :            :         }
     172                 :            : 
     173                 :          0 :         trace_rtc_set_time(rtc_tm_to_time64(tm), err);
     174                 :          0 :         return err;
     175                 :            : }
     176                 :            : EXPORT_SYMBOL_GPL(rtc_set_time);
     177                 :            : 
     178                 :         11 : static int rtc_read_alarm_internal(struct rtc_device *rtc,
     179                 :            :                                    struct rtc_wkalrm *alarm)
     180                 :            : {
     181                 :         11 :         int err;
     182                 :            : 
     183                 :         11 :         err = mutex_lock_interruptible(&rtc->ops_lock);
     184         [ +  - ]:         11 :         if (err)
     185                 :            :                 return err;
     186                 :            : 
     187         [ +  - ]:         11 :         if (!rtc->ops) {
     188                 :            :                 err = -ENODEV;
     189         [ +  - ]:         11 :         } else if (!rtc->ops->read_alarm) {
     190                 :            :                 err = -EINVAL;
     191                 :            :         } else {
     192                 :         11 :                 alarm->enabled = 0;
     193                 :         11 :                 alarm->pending = 0;
     194                 :         11 :                 alarm->time.tm_sec = -1;
     195                 :         11 :                 alarm->time.tm_min = -1;
     196                 :         11 :                 alarm->time.tm_hour = -1;
     197                 :         11 :                 alarm->time.tm_mday = -1;
     198                 :         11 :                 alarm->time.tm_mon = -1;
     199                 :         11 :                 alarm->time.tm_year = -1;
     200                 :         11 :                 alarm->time.tm_wday = -1;
     201                 :         11 :                 alarm->time.tm_yday = -1;
     202                 :         11 :                 alarm->time.tm_isdst = -1;
     203                 :         11 :                 err = rtc->ops->read_alarm(rtc->dev.parent, alarm);
     204                 :            :         }
     205                 :            : 
     206                 :         11 :         mutex_unlock(&rtc->ops_lock);
     207                 :            : 
     208                 :         11 :         trace_rtc_read_alarm(rtc_tm_to_time64(&alarm->time), err);
     209                 :         11 :         return err;
     210                 :            : }
     211                 :            : 
     212                 :         11 : int __rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
     213                 :            : {
     214                 :         11 :         int err;
     215                 :         11 :         struct rtc_time before, now;
     216                 :         11 :         int first_time = 1;
     217                 :         11 :         time64_t t_now, t_alm;
     218                 :         11 :         enum { none, day, month, year } missing = none;
     219                 :         11 :         unsigned int days;
     220                 :            : 
     221                 :            :         /* The lower level RTC driver may return -1 in some fields,
     222                 :            :          * creating invalid alarm->time values, for reasons like:
     223                 :            :          *
     224                 :            :          *   - The hardware may not be capable of filling them in;
     225                 :            :          *     many alarms match only on time-of-day fields, not
     226                 :            :          *     day/month/year calendar data.
     227                 :            :          *
     228                 :            :          *   - Some hardware uses illegal values as "wildcard" match
     229                 :            :          *     values, which non-Linux firmware (like a BIOS) may try
     230                 :            :          *     to set up as e.g. "alarm 15 minutes after each hour".
     231                 :            :          *     Linux uses only oneshot alarms.
     232                 :            :          *
     233                 :            :          * When we see that here, we deal with it by using values from
     234                 :            :          * a current RTC timestamp for any missing (-1) values.  The
     235                 :            :          * RTC driver prevents "periodic alarm" modes.
     236                 :            :          *
     237                 :            :          * But this can be racey, because some fields of the RTC timestamp
     238                 :            :          * may have wrapped in the interval since we read the RTC alarm,
     239                 :            :          * which would lead to us inserting inconsistent values in place
     240                 :            :          * of the -1 fields.
     241                 :            :          *
     242                 :            :          * Reading the alarm and timestamp in the reverse sequence
     243                 :            :          * would have the same race condition, and not solve the issue.
     244                 :            :          *
     245                 :            :          * So, we must first read the RTC timestamp,
     246                 :            :          * then read the RTC alarm value,
     247                 :            :          * and then read a second RTC timestamp.
     248                 :            :          *
     249                 :            :          * If any fields of the second timestamp have changed
     250                 :            :          * when compared with the first timestamp, then we know
     251                 :            :          * our timestamp may be inconsistent with that used by
     252                 :            :          * the low-level rtc_read_alarm_internal() function.
     253                 :            :          *
     254                 :            :          * So, when the two timestamps disagree, we just loop and do
     255                 :            :          * the process again to get a fully consistent set of values.
     256                 :            :          *
     257                 :            :          * This could all instead be done in the lower level driver,
     258                 :            :          * but since more than one lower level RTC implementation needs it,
     259                 :            :          * then it's probably best best to do it here instead of there..
     260                 :            :          */
     261                 :            : 
     262                 :            :         /* Get the "before" timestamp */
     263                 :         11 :         err = rtc_read_time(rtc, &before);
     264         [ +  - ]:         11 :         if (err < 0)
     265                 :            :                 return err;
     266                 :            :         do {
     267                 :            :                 if (!first_time)
     268                 :          0 :                         memcpy(&before, &now, sizeof(struct rtc_time));
     269                 :         11 :                 first_time = 0;
     270                 :            : 
     271                 :            :                 /* get the RTC alarm values, which may be incomplete */
     272                 :         11 :                 err = rtc_read_alarm_internal(rtc, alarm);
     273         [ -  + ]:         11 :                 if (err)
     274                 :          0 :                         return err;
     275                 :            : 
     276                 :            :                 /* full-function RTCs won't have such missing fields */
     277         [ -  + ]:         11 :                 if (rtc_valid_tm(&alarm->time) == 0) {
     278                 :          0 :                         rtc_add_offset(rtc, &alarm->time);
     279                 :          0 :                         return 0;
     280                 :            :                 }
     281                 :            : 
     282                 :            :                 /* get the "after" timestamp, to detect wrapped fields */
     283                 :         11 :                 err = rtc_read_time(rtc, &now);
     284         [ -  + ]:         11 :                 if (err < 0)
     285                 :          0 :                         return err;
     286                 :            : 
     287                 :            :                 /* note that tm_sec is a "don't care" value here: */
     288                 :         22 :         } while (before.tm_min  != now.tm_min ||
     289         [ -  + ]:         11 :                  before.tm_hour != now.tm_hour ||
     290         [ -  + ]:         11 :                  before.tm_mon  != now.tm_mon ||
     291   [ -  +  -  + ]:         22 :                  before.tm_year != now.tm_year);
     292                 :            : 
     293                 :            :         /* Fill in the missing alarm fields using the timestamp; we
     294                 :            :          * know there's at least one since alarm->time is invalid.
     295                 :            :          */
     296         [ -  + ]:         11 :         if (alarm->time.tm_sec == -1)
     297                 :          0 :                 alarm->time.tm_sec = now.tm_sec;
     298         [ -  + ]:         11 :         if (alarm->time.tm_min == -1)
     299                 :          0 :                 alarm->time.tm_min = now.tm_min;
     300         [ -  + ]:         11 :         if (alarm->time.tm_hour == -1)
     301                 :          0 :                 alarm->time.tm_hour = now.tm_hour;
     302                 :            : 
     303                 :            :         /* For simplicity, only support date rollover for now */
     304         [ +  - ]:         11 :         if (alarm->time.tm_mday < 1 || alarm->time.tm_mday > 31) {
     305                 :         11 :                 alarm->time.tm_mday = now.tm_mday;
     306                 :         11 :                 missing = day;
     307                 :            :         }
     308         [ +  - ]:         11 :         if ((unsigned int)alarm->time.tm_mon >= 12) {
     309                 :         11 :                 alarm->time.tm_mon = now.tm_mon;
     310         [ -  + ]:         11 :                 if (missing == none)
     311                 :          0 :                         missing = month;
     312                 :            :         }
     313         [ +  - ]:         11 :         if (alarm->time.tm_year == -1) {
     314                 :         11 :                 alarm->time.tm_year = now.tm_year;
     315         [ -  + ]:         11 :                 if (missing == none)
     316                 :          0 :                         missing = year;
     317                 :            :         }
     318                 :            : 
     319                 :            :         /* Can't proceed if alarm is still invalid after replacing
     320                 :            :          * missing fields.
     321                 :            :          */
     322                 :         11 :         err = rtc_valid_tm(&alarm->time);
     323         [ -  + ]:         11 :         if (err)
     324                 :          0 :                 goto done;
     325                 :            : 
     326                 :            :         /* with luck, no rollover is needed */
     327                 :         11 :         t_now = rtc_tm_to_time64(&now);
     328                 :         11 :         t_alm = rtc_tm_to_time64(&alarm->time);
     329         [ -  + ]:         11 :         if (t_now < t_alm)
     330                 :          0 :                 goto done;
     331                 :            : 
     332   [ +  -  -  - ]:         11 :         switch (missing) {
     333                 :            :         /* 24 hour rollover ... if it's now 10am Monday, an alarm that
     334                 :            :          * that will trigger at 5am will do so at 5am Tuesday, which
     335                 :            :          * could also be in the next month or year.  This is a common
     336                 :            :          * case, especially for PCs.
     337                 :            :          */
     338                 :            :         case day:
     339                 :         11 :                 dev_dbg(&rtc->dev, "alarm rollover: %s\n", "day");
     340                 :         11 :                 t_alm += 24 * 60 * 60;
     341                 :         11 :                 rtc_time64_to_tm(t_alm, &alarm->time);
     342                 :         11 :                 break;
     343                 :            : 
     344                 :            :         /* Month rollover ... if it's the 31th, an alarm on the 3rd will
     345                 :            :          * be next month.  An alarm matching on the 30th, 29th, or 28th
     346                 :            :          * may end up in the month after that!  Many newer PCs support
     347                 :            :          * this type of alarm.
     348                 :            :          */
     349                 :            :         case month:
     350                 :            :                 dev_dbg(&rtc->dev, "alarm rollover: %s\n", "month");
     351                 :          0 :                 do {
     352         [ #  # ]:          0 :                         if (alarm->time.tm_mon < 11) {
     353                 :          0 :                                 alarm->time.tm_mon++;
     354                 :            :                         } else {
     355                 :          0 :                                 alarm->time.tm_mon = 0;
     356                 :          0 :                                 alarm->time.tm_year++;
     357                 :            :                         }
     358                 :          0 :                         days = rtc_month_days(alarm->time.tm_mon,
     359                 :          0 :                                               alarm->time.tm_year);
     360         [ #  # ]:          0 :                 } while (days < alarm->time.tm_mday);
     361                 :            :                 break;
     362                 :            : 
     363                 :            :         /* Year rollover ... easy except for leap years! */
     364                 :            :         case year:
     365                 :            :                 dev_dbg(&rtc->dev, "alarm rollover: %s\n", "year");
     366                 :          0 :                 do {
     367                 :          0 :                         alarm->time.tm_year++;
     368   [ #  #  #  # ]:          0 :                 } while (!is_leap_year(alarm->time.tm_year + 1900) &&
     369         [ #  # ]:          0 :                          rtc_valid_tm(&alarm->time) != 0);
     370                 :            :                 break;
     371                 :            : 
     372                 :          0 :         default:
     373                 :          0 :                 dev_warn(&rtc->dev, "alarm rollover not handled\n");
     374                 :            :         }
     375                 :            : 
     376                 :         11 :         err = rtc_valid_tm(&alarm->time);
     377                 :            : 
     378                 :         11 : done:
     379         [ -  + ]:         11 :         if (err)
     380                 :          0 :                 dev_warn(&rtc->dev, "invalid alarm value: %ptR\n",
     381                 :            :                          &alarm->time);
     382                 :            : 
     383                 :            :         return err;
     384                 :            : }
     385                 :            : 
     386                 :          0 : int rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
     387                 :            : {
     388                 :          0 :         int err;
     389                 :            : 
     390                 :          0 :         err = mutex_lock_interruptible(&rtc->ops_lock);
     391         [ #  # ]:          0 :         if (err)
     392                 :            :                 return err;
     393         [ #  # ]:          0 :         if (!rtc->ops) {
     394                 :            :                 err = -ENODEV;
     395         [ #  # ]:          0 :         } else if (!rtc->ops->read_alarm) {
     396                 :            :                 err = -EINVAL;
     397                 :            :         } else {
     398                 :          0 :                 memset(alarm, 0, sizeof(struct rtc_wkalrm));
     399                 :          0 :                 alarm->enabled = rtc->aie_timer.enabled;
     400                 :          0 :                 alarm->time = rtc_ktime_to_tm(rtc->aie_timer.node.expires);
     401                 :            :         }
     402                 :          0 :         mutex_unlock(&rtc->ops_lock);
     403                 :            : 
     404                 :          0 :         trace_rtc_read_alarm(rtc_tm_to_time64(&alarm->time), err);
     405                 :          0 :         return err;
     406                 :            : }
     407                 :            : EXPORT_SYMBOL_GPL(rtc_read_alarm);
     408                 :            : 
     409                 :          0 : static int __rtc_set_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
     410                 :            : {
     411                 :          0 :         struct rtc_time tm;
     412                 :          0 :         time64_t now, scheduled;
     413                 :          0 :         int err;
     414                 :            : 
     415                 :          0 :         err = rtc_valid_tm(&alarm->time);
     416         [ #  # ]:          0 :         if (err)
     417                 :            :                 return err;
     418                 :            : 
     419                 :          0 :         scheduled = rtc_tm_to_time64(&alarm->time);
     420                 :            : 
     421                 :            :         /* Make sure we're not setting alarms in the past */
     422                 :          0 :         err = __rtc_read_time(rtc, &tm);
     423         [ #  # ]:          0 :         if (err)
     424                 :            :                 return err;
     425                 :          0 :         now = rtc_tm_to_time64(&tm);
     426         [ #  # ]:          0 :         if (scheduled <= now)
     427                 :            :                 return -ETIME;
     428                 :            :         /*
     429                 :            :          * XXX - We just checked to make sure the alarm time is not
     430                 :            :          * in the past, but there is still a race window where if
     431                 :            :          * the is alarm set for the next second and the second ticks
     432                 :            :          * over right here, before we set the alarm.
     433                 :            :          */
     434                 :            : 
     435                 :          0 :         rtc_subtract_offset(rtc, &alarm->time);
     436                 :            : 
     437         [ #  # ]:          0 :         if (!rtc->ops)
     438                 :            :                 err = -ENODEV;
     439         [ #  # ]:          0 :         else if (!rtc->ops->set_alarm)
     440                 :            :                 err = -EINVAL;
     441                 :            :         else
     442                 :          0 :                 err = rtc->ops->set_alarm(rtc->dev.parent, alarm);
     443                 :            : 
     444                 :          0 :         trace_rtc_set_alarm(rtc_tm_to_time64(&alarm->time), err);
     445                 :          0 :         return err;
     446                 :            : }
     447                 :            : 
     448                 :          0 : int rtc_set_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
     449                 :            : {
     450                 :          0 :         int err;
     451                 :            : 
     452         [ #  # ]:          0 :         if (!rtc->ops)
     453                 :            :                 return -ENODEV;
     454         [ #  # ]:          0 :         else if (!rtc->ops->set_alarm)
     455                 :            :                 return -EINVAL;
     456                 :            : 
     457                 :          0 :         err = rtc_valid_tm(&alarm->time);
     458         [ #  # ]:          0 :         if (err != 0)
     459                 :            :                 return err;
     460                 :            : 
     461                 :          0 :         err = rtc_valid_range(rtc, &alarm->time);
     462         [ #  # ]:          0 :         if (err)
     463                 :            :                 return err;
     464                 :            : 
     465                 :          0 :         err = mutex_lock_interruptible(&rtc->ops_lock);
     466         [ #  # ]:          0 :         if (err)
     467                 :            :                 return err;
     468         [ #  # ]:          0 :         if (rtc->aie_timer.enabled)
     469                 :          0 :                 rtc_timer_remove(rtc, &rtc->aie_timer);
     470                 :            : 
     471                 :          0 :         rtc->aie_timer.node.expires = rtc_tm_to_ktime(alarm->time);
     472                 :          0 :         rtc->aie_timer.period = 0;
     473         [ #  # ]:          0 :         if (alarm->enabled)
     474                 :          0 :                 err = rtc_timer_enqueue(rtc, &rtc->aie_timer);
     475                 :            : 
     476                 :          0 :         mutex_unlock(&rtc->ops_lock);
     477                 :            : 
     478                 :          0 :         return err;
     479                 :            : }
     480                 :            : EXPORT_SYMBOL_GPL(rtc_set_alarm);
     481                 :            : 
     482                 :            : /* Called once per device from rtc_device_register */
     483                 :         11 : int rtc_initialize_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
     484                 :            : {
     485                 :         11 :         int err;
     486                 :         11 :         struct rtc_time now;
     487                 :            : 
     488                 :         11 :         err = rtc_valid_tm(&alarm->time);
     489         [ +  - ]:         11 :         if (err != 0)
     490                 :            :                 return err;
     491                 :            : 
     492                 :         11 :         err = rtc_read_time(rtc, &now);
     493         [ +  - ]:         11 :         if (err)
     494                 :            :                 return err;
     495                 :            : 
     496                 :         11 :         err = mutex_lock_interruptible(&rtc->ops_lock);
     497         [ +  - ]:         11 :         if (err)
     498                 :            :                 return err;
     499                 :            : 
     500                 :         11 :         rtc->aie_timer.node.expires = rtc_tm_to_ktime(alarm->time);
     501                 :         11 :         rtc->aie_timer.period = 0;
     502                 :            : 
     503                 :            :         /* Alarm has to be enabled & in the future for us to enqueue it */
     504         [ -  + ]:         11 :         if (alarm->enabled && (rtc_tm_to_ktime(now) <
     505         [ #  # ]:          0 :                          rtc->aie_timer.node.expires)) {
     506                 :          0 :                 rtc->aie_timer.enabled = 1;
     507                 :          0 :                 timerqueue_add(&rtc->timerqueue, &rtc->aie_timer.node);
     508                 :          0 :                 trace_rtc_timer_enqueue(&rtc->aie_timer);
     509                 :            :         }
     510                 :         11 :         mutex_unlock(&rtc->ops_lock);
     511                 :         11 :         return err;
     512                 :            : }
     513                 :            : EXPORT_SYMBOL_GPL(rtc_initialize_alarm);
     514                 :            : 
     515                 :          0 : int rtc_alarm_irq_enable(struct rtc_device *rtc, unsigned int enabled)
     516                 :            : {
     517                 :          0 :         int err;
     518                 :            : 
     519                 :          0 :         err = mutex_lock_interruptible(&rtc->ops_lock);
     520         [ #  # ]:          0 :         if (err)
     521                 :            :                 return err;
     522                 :            : 
     523         [ #  # ]:          0 :         if (rtc->aie_timer.enabled != enabled) {
     524         [ #  # ]:          0 :                 if (enabled)
     525                 :          0 :                         err = rtc_timer_enqueue(rtc, &rtc->aie_timer);
     526                 :            :                 else
     527                 :          0 :                         rtc_timer_remove(rtc, &rtc->aie_timer);
     528                 :            :         }
     529                 :            : 
     530         [ #  # ]:          0 :         if (err)
     531                 :            :                 /* nothing */;
     532         [ #  # ]:          0 :         else if (!rtc->ops)
     533                 :            :                 err = -ENODEV;
     534         [ #  # ]:          0 :         else if (!rtc->ops->alarm_irq_enable)
     535                 :            :                 err = -EINVAL;
     536                 :            :         else
     537                 :          0 :                 err = rtc->ops->alarm_irq_enable(rtc->dev.parent, enabled);
     538                 :            : 
     539                 :          0 :         mutex_unlock(&rtc->ops_lock);
     540                 :            : 
     541                 :          0 :         trace_rtc_alarm_irq_enable(enabled, err);
     542                 :          0 :         return err;
     543                 :            : }
     544                 :            : EXPORT_SYMBOL_GPL(rtc_alarm_irq_enable);
     545                 :            : 
     546                 :          0 : int rtc_update_irq_enable(struct rtc_device *rtc, unsigned int enabled)
     547                 :            : {
     548                 :          0 :         int rc = 0, err;
     549                 :            : 
     550                 :          0 :         err = mutex_lock_interruptible(&rtc->ops_lock);
     551         [ #  # ]:          0 :         if (err)
     552                 :            :                 return err;
     553                 :            : 
     554                 :            : #ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
     555                 :            :         if (enabled == 0 && rtc->uie_irq_active) {
     556                 :            :                 mutex_unlock(&rtc->ops_lock);
     557                 :            :                 return rtc_dev_update_irq_enable_emul(rtc, 0);
     558                 :            :         }
     559                 :            : #endif
     560                 :            :         /* make sure we're changing state */
     561         [ #  # ]:          0 :         if (rtc->uie_rtctimer.enabled == enabled)
     562                 :          0 :                 goto out;
     563                 :            : 
     564         [ #  # ]:          0 :         if (rtc->uie_unsupported) {
     565                 :          0 :                 err = -EINVAL;
     566                 :          0 :                 goto out;
     567                 :            :         }
     568                 :            : 
     569         [ #  # ]:          0 :         if (enabled) {
     570                 :          0 :                 struct rtc_time tm;
     571                 :          0 :                 ktime_t now, onesec;
     572                 :            : 
     573                 :          0 :                 rc = __rtc_read_time(rtc, &tm);
     574         [ #  # ]:          0 :                 if (rc)
     575                 :          0 :                         goto out;
     576                 :          0 :                 onesec = ktime_set(1, 0);
     577                 :          0 :                 now = rtc_tm_to_ktime(tm);
     578                 :          0 :                 rtc->uie_rtctimer.node.expires = ktime_add(now, onesec);
     579                 :          0 :                 rtc->uie_rtctimer.period = ktime_set(1, 0);
     580                 :          0 :                 err = rtc_timer_enqueue(rtc, &rtc->uie_rtctimer);
     581                 :            :         } else {
     582                 :          0 :                 rtc_timer_remove(rtc, &rtc->uie_rtctimer);
     583                 :            :         }
     584                 :            : 
     585                 :          0 : out:
     586                 :          0 :         mutex_unlock(&rtc->ops_lock);
     587                 :            : 
     588                 :            :         /*
     589                 :            :          * __rtc_read_time() failed, this probably means that the RTC time has
     590                 :            :          * never been set or less probably there is a transient error on the
     591                 :            :          * bus. In any case, avoid enabling emulation has this will fail when
     592                 :            :          * reading the time too.
     593                 :            :          */
     594         [ #  # ]:          0 :         if (rc)
     595                 :          0 :                 return rc;
     596                 :            : 
     597                 :            : #ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
     598                 :            :         /*
     599                 :            :          * Enable emulation if the driver returned -EINVAL to signal that it has
     600                 :            :          * been configured without interrupts or they are not available at the
     601                 :            :          * moment.
     602                 :            :          */
     603                 :            :         if (err == -EINVAL)
     604                 :            :                 err = rtc_dev_update_irq_enable_emul(rtc, enabled);
     605                 :            : #endif
     606                 :            :         return err;
     607                 :            : }
     608                 :            : EXPORT_SYMBOL_GPL(rtc_update_irq_enable);
     609                 :            : 
     610                 :            : /**
     611                 :            :  * rtc_handle_legacy_irq - AIE, UIE and PIE event hook
     612                 :            :  * @rtc: pointer to the rtc device
     613                 :            :  * @num: number of occurence of the event
     614                 :            :  * @mode: type of the event, RTC_AF, RTC_UF of RTC_PF
     615                 :            :  *
     616                 :            :  * This function is called when an AIE, UIE or PIE mode interrupt
     617                 :            :  * has occurred (or been emulated).
     618                 :            :  *
     619                 :            :  */
     620                 :          0 : void rtc_handle_legacy_irq(struct rtc_device *rtc, int num, int mode)
     621                 :            : {
     622                 :          0 :         unsigned long flags;
     623                 :            : 
     624                 :            :         /* mark one irq of the appropriate mode */
     625                 :          0 :         spin_lock_irqsave(&rtc->irq_lock, flags);
     626                 :          0 :         rtc->irq_data = (rtc->irq_data + (num << 8)) | (RTC_IRQF | mode);
     627                 :          0 :         spin_unlock_irqrestore(&rtc->irq_lock, flags);
     628                 :            : 
     629                 :          0 :         wake_up_interruptible(&rtc->irq_queue);
     630                 :          0 :         kill_fasync(&rtc->async_queue, SIGIO, POLL_IN);
     631                 :          0 : }
     632                 :            : 
     633                 :            : /**
     634                 :            :  * rtc_aie_update_irq - AIE mode rtctimer hook
     635                 :            :  * @rtc: pointer to the rtc_device
     636                 :            :  *
     637                 :            :  * This functions is called when the aie_timer expires.
     638                 :            :  */
     639                 :          0 : void rtc_aie_update_irq(struct rtc_device *rtc)
     640                 :            : {
     641                 :          0 :         rtc_handle_legacy_irq(rtc, 1, RTC_AF);
     642                 :          0 : }
     643                 :            : 
     644                 :            : /**
     645                 :            :  * rtc_uie_update_irq - UIE mode rtctimer hook
     646                 :            :  * @rtc: pointer to the rtc_device
     647                 :            :  *
     648                 :            :  * This functions is called when the uie_timer expires.
     649                 :            :  */
     650                 :          0 : void rtc_uie_update_irq(struct rtc_device *rtc)
     651                 :            : {
     652                 :          0 :         rtc_handle_legacy_irq(rtc, 1,  RTC_UF);
     653                 :          0 : }
     654                 :            : 
     655                 :            : /**
     656                 :            :  * rtc_pie_update_irq - PIE mode hrtimer hook
     657                 :            :  * @timer: pointer to the pie mode hrtimer
     658                 :            :  *
     659                 :            :  * This function is used to emulate PIE mode interrupts
     660                 :            :  * using an hrtimer. This function is called when the periodic
     661                 :            :  * hrtimer expires.
     662                 :            :  */
     663                 :          0 : enum hrtimer_restart rtc_pie_update_irq(struct hrtimer *timer)
     664                 :            : {
     665                 :          0 :         struct rtc_device *rtc;
     666                 :          0 :         ktime_t period;
     667                 :          0 :         u64 count;
     668                 :            : 
     669                 :          0 :         rtc = container_of(timer, struct rtc_device, pie_timer);
     670                 :            : 
     671                 :          0 :         period = NSEC_PER_SEC / rtc->irq_freq;
     672                 :          0 :         count = hrtimer_forward_now(timer, period);
     673                 :            : 
     674                 :          0 :         rtc_handle_legacy_irq(rtc, count, RTC_PF);
     675                 :            : 
     676                 :          0 :         return HRTIMER_RESTART;
     677                 :            : }
     678                 :            : 
     679                 :            : /**
     680                 :            :  * rtc_update_irq - Triggered when a RTC interrupt occurs.
     681                 :            :  * @rtc: the rtc device
     682                 :            :  * @num: how many irqs are being reported (usually one)
     683                 :            :  * @events: mask of RTC_IRQF with one or more of RTC_PF, RTC_AF, RTC_UF
     684                 :            :  * Context: any
     685                 :            :  */
     686                 :          0 : void rtc_update_irq(struct rtc_device *rtc,
     687                 :            :                     unsigned long num, unsigned long events)
     688                 :            : {
     689   [ #  #  #  # ]:          0 :         if (IS_ERR_OR_NULL(rtc))
     690                 :            :                 return;
     691                 :            : 
     692                 :          0 :         pm_stay_awake(rtc->dev.parent);
     693                 :          0 :         schedule_work(&rtc->irqwork);
     694                 :            : }
     695                 :            : EXPORT_SYMBOL_GPL(rtc_update_irq);
     696                 :            : 
     697                 :          0 : struct rtc_device *rtc_class_open(const char *name)
     698                 :            : {
     699                 :          0 :         struct device *dev;
     700                 :          0 :         struct rtc_device *rtc = NULL;
     701                 :            : 
     702                 :          0 :         dev = class_find_device_by_name(rtc_class, name);
     703         [ #  # ]:          0 :         if (dev)
     704                 :          0 :                 rtc = to_rtc_device(dev);
     705                 :            : 
     706                 :          0 :         if (rtc) {
     707         [ #  # ]:          0 :                 if (!try_module_get(rtc->owner)) {
     708                 :          0 :                         put_device(dev);
     709                 :          0 :                         rtc = NULL;
     710                 :            :                 }
     711                 :            :         }
     712                 :            : 
     713                 :          0 :         return rtc;
     714                 :            : }
     715                 :            : EXPORT_SYMBOL_GPL(rtc_class_open);
     716                 :            : 
     717                 :          0 : void rtc_class_close(struct rtc_device *rtc)
     718                 :            : {
     719                 :          0 :         module_put(rtc->owner);
     720                 :          0 :         put_device(&rtc->dev);
     721                 :          0 : }
     722                 :            : EXPORT_SYMBOL_GPL(rtc_class_close);
     723                 :            : 
     724                 :          0 : static int rtc_update_hrtimer(struct rtc_device *rtc, int enabled)
     725                 :            : {
     726                 :            :         /*
     727                 :            :          * We always cancel the timer here first, because otherwise
     728                 :            :          * we could run into BUG_ON(timer->state != HRTIMER_STATE_CALLBACK);
     729                 :            :          * when we manage to start the timer before the callback
     730                 :            :          * returns HRTIMER_RESTART.
     731                 :            :          *
     732                 :            :          * We cannot use hrtimer_cancel() here as a running callback
     733                 :            :          * could be blocked on rtc->irq_task_lock and hrtimer_cancel()
     734                 :            :          * would spin forever.
     735                 :            :          */
     736         [ #  # ]:          0 :         if (hrtimer_try_to_cancel(&rtc->pie_timer) < 0)
     737                 :            :                 return -1;
     738                 :            : 
     739         [ #  # ]:          0 :         if (enabled) {
     740                 :          0 :                 ktime_t period = NSEC_PER_SEC / rtc->irq_freq;
     741                 :            : 
     742                 :          0 :                 hrtimer_start(&rtc->pie_timer, period, HRTIMER_MODE_REL);
     743                 :            :         }
     744                 :            :         return 0;
     745                 :            : }
     746                 :            : 
     747                 :            : /**
     748                 :            :  * rtc_irq_set_state - enable/disable 2^N Hz periodic IRQs
     749                 :            :  * @rtc: the rtc device
     750                 :            :  * @enabled: true to enable periodic IRQs
     751                 :            :  * Context: any
     752                 :            :  *
     753                 :            :  * Note that rtc_irq_set_freq() should previously have been used to
     754                 :            :  * specify the desired frequency of periodic IRQ.
     755                 :            :  */
     756                 :          0 : int rtc_irq_set_state(struct rtc_device *rtc, int enabled)
     757                 :            : {
     758                 :          0 :         int err = 0;
     759                 :            : 
     760         [ #  # ]:          0 :         while (rtc_update_hrtimer(rtc, enabled) < 0)
     761                 :          0 :                 cpu_relax();
     762                 :            : 
     763                 :          0 :         rtc->pie_enabled = enabled;
     764                 :            : 
     765                 :          0 :         trace_rtc_irq_set_state(enabled, err);
     766                 :          0 :         return err;
     767                 :            : }
     768                 :            : 
     769                 :            : /**
     770                 :            :  * rtc_irq_set_freq - set 2^N Hz periodic IRQ frequency for IRQ
     771                 :            :  * @rtc: the rtc device
     772                 :            :  * @freq: positive frequency
     773                 :            :  * Context: any
     774                 :            :  *
     775                 :            :  * Note that rtc_irq_set_state() is used to enable or disable the
     776                 :            :  * periodic IRQs.
     777                 :            :  */
     778                 :          0 : int rtc_irq_set_freq(struct rtc_device *rtc, int freq)
     779                 :            : {
     780                 :          0 :         int err = 0;
     781                 :            : 
     782         [ #  # ]:          0 :         if (freq <= 0 || freq > RTC_MAX_FREQ)
     783                 :            :                 return -EINVAL;
     784                 :            : 
     785                 :          0 :         rtc->irq_freq = freq;
     786   [ #  #  #  # ]:          0 :         while (rtc->pie_enabled && rtc_update_hrtimer(rtc, 1) < 0)
     787                 :          0 :                 cpu_relax();
     788                 :            : 
     789                 :          0 :         trace_rtc_irq_set_freq(freq, err);
     790                 :          0 :         return err;
     791                 :            : }
     792                 :            : 
     793                 :            : /**
     794                 :            :  * rtc_timer_enqueue - Adds a rtc_timer to the rtc_device timerqueue
     795                 :            :  * @rtc: rtc device
     796                 :            :  * @timer: timer being added.
     797                 :            :  *
     798                 :            :  * Enqueues a timer onto the rtc devices timerqueue and sets
     799                 :            :  * the next alarm event appropriately.
     800                 :            :  *
     801                 :            :  * Sets the enabled bit on the added timer.
     802                 :            :  *
     803                 :            :  * Must hold ops_lock for proper serialization of timerqueue
     804                 :            :  */
     805                 :          0 : static int rtc_timer_enqueue(struct rtc_device *rtc, struct rtc_timer *timer)
     806                 :            : {
     807                 :          0 :         struct timerqueue_node *next = timerqueue_getnext(&rtc->timerqueue);
     808                 :          0 :         struct rtc_time tm;
     809                 :          0 :         ktime_t now;
     810                 :            : 
     811                 :          0 :         timer->enabled = 1;
     812                 :          0 :         __rtc_read_time(rtc, &tm);
     813                 :          0 :         now = rtc_tm_to_ktime(tm);
     814                 :            : 
     815                 :            :         /* Skip over expired timers */
     816         [ #  # ]:          0 :         while (next) {
     817         [ #  # ]:          0 :                 if (next->expires >= now)
     818                 :            :                         break;
     819                 :          0 :                 next = timerqueue_iterate_next(next);
     820                 :            :         }
     821                 :            : 
     822                 :          0 :         timerqueue_add(&rtc->timerqueue, &timer->node);
     823                 :          0 :         trace_rtc_timer_enqueue(timer);
     824   [ #  #  #  # ]:          0 :         if (!next || ktime_before(timer->node.expires, next->expires)) {
     825                 :          0 :                 struct rtc_wkalrm alarm;
     826                 :          0 :                 int err;
     827                 :            : 
     828                 :          0 :                 alarm.time = rtc_ktime_to_tm(timer->node.expires);
     829                 :          0 :                 alarm.enabled = 1;
     830                 :          0 :                 err = __rtc_set_alarm(rtc, &alarm);
     831         [ #  # ]:          0 :                 if (err == -ETIME) {
     832                 :          0 :                         pm_stay_awake(rtc->dev.parent);
     833                 :          0 :                         schedule_work(&rtc->irqwork);
     834         [ #  # ]:          0 :                 } else if (err) {
     835                 :          0 :                         timerqueue_del(&rtc->timerqueue, &timer->node);
     836                 :          0 :                         trace_rtc_timer_dequeue(timer);
     837                 :          0 :                         timer->enabled = 0;
     838                 :          0 :                         return err;
     839                 :            :                 }
     840                 :            :         }
     841                 :            :         return 0;
     842                 :            : }
     843                 :            : 
     844                 :            : static void rtc_alarm_disable(struct rtc_device *rtc)
     845                 :            : {
     846                 :            :         if (!rtc->ops || !rtc->ops->alarm_irq_enable)
     847                 :            :                 return;
     848                 :            : 
     849                 :            :         rtc->ops->alarm_irq_enable(rtc->dev.parent, false);
     850                 :            :         trace_rtc_alarm_irq_enable(0, 0);
     851                 :            : }
     852                 :            : 
     853                 :            : /**
     854                 :            :  * rtc_timer_remove - Removes a rtc_timer from the rtc_device timerqueue
     855                 :            :  * @rtc: rtc device
     856                 :            :  * @timer: timer being removed.
     857                 :            :  *
     858                 :            :  * Removes a timer onto the rtc devices timerqueue and sets
     859                 :            :  * the next alarm event appropriately.
     860                 :            :  *
     861                 :            :  * Clears the enabled bit on the removed timer.
     862                 :            :  *
     863                 :            :  * Must hold ops_lock for proper serialization of timerqueue
     864                 :            :  */
     865                 :          0 : static void rtc_timer_remove(struct rtc_device *rtc, struct rtc_timer *timer)
     866                 :            : {
     867                 :          0 :         struct timerqueue_node *next = timerqueue_getnext(&rtc->timerqueue);
     868                 :            : 
     869                 :          0 :         timerqueue_del(&rtc->timerqueue, &timer->node);
     870                 :          0 :         trace_rtc_timer_dequeue(timer);
     871                 :          0 :         timer->enabled = 0;
     872         [ #  # ]:          0 :         if (next == &timer->node) {
     873                 :          0 :                 struct rtc_wkalrm alarm;
     874                 :          0 :                 int err;
     875                 :            : 
     876         [ #  # ]:          0 :                 next = timerqueue_getnext(&rtc->timerqueue);
     877         [ #  # ]:          0 :                 if (!next) {
     878                 :          0 :                         rtc_alarm_disable(rtc);
     879                 :          0 :                         return;
     880                 :            :                 }
     881                 :          0 :                 alarm.time = rtc_ktime_to_tm(next->expires);
     882                 :          0 :                 alarm.enabled = 1;
     883                 :          0 :                 err = __rtc_set_alarm(rtc, &alarm);
     884         [ #  # ]:          0 :                 if (err == -ETIME) {
     885                 :          0 :                         pm_stay_awake(rtc->dev.parent);
     886                 :          0 :                         schedule_work(&rtc->irqwork);
     887                 :            :                 }
     888                 :            :         }
     889                 :            : }
     890                 :            : 
     891                 :            : /**
     892                 :            :  * rtc_timer_do_work - Expires rtc timers
     893                 :            :  * @work: work item
     894                 :            :  *
     895                 :            :  * Expires rtc timers. Reprograms next alarm event if needed.
     896                 :            :  * Called via worktask.
     897                 :            :  *
     898                 :            :  * Serializes access to timerqueue via ops_lock mutex
     899                 :            :  */
     900                 :          0 : void rtc_timer_do_work(struct work_struct *work)
     901                 :            : {
     902                 :          0 :         struct rtc_timer *timer;
     903                 :          0 :         struct timerqueue_node *next;
     904                 :          0 :         ktime_t now;
     905                 :          0 :         struct rtc_time tm;
     906                 :            : 
     907                 :          0 :         struct rtc_device *rtc =
     908                 :          0 :                 container_of(work, struct rtc_device, irqwork);
     909                 :            : 
     910                 :          0 :         mutex_lock(&rtc->ops_lock);
     911                 :          0 : again:
     912                 :          0 :         __rtc_read_time(rtc, &tm);
     913                 :          0 :         now = rtc_tm_to_ktime(tm);
     914         [ #  # ]:          0 :         while ((next = timerqueue_getnext(&rtc->timerqueue))) {
     915         [ #  # ]:          0 :                 if (next->expires > now)
     916                 :            :                         break;
     917                 :            : 
     918                 :            :                 /* expire timer */
     919                 :          0 :                 timer = container_of(next, struct rtc_timer, node);
     920                 :          0 :                 timerqueue_del(&rtc->timerqueue, &timer->node);
     921                 :          0 :                 trace_rtc_timer_dequeue(timer);
     922                 :          0 :                 timer->enabled = 0;
     923         [ #  # ]:          0 :                 if (timer->func)
     924                 :          0 :                         timer->func(timer->rtc);
     925                 :            : 
     926                 :          0 :                 trace_rtc_timer_fired(timer);
     927                 :            :                 /* Re-add/fwd periodic timers */
     928         [ #  # ]:          0 :                 if (ktime_to_ns(timer->period)) {
     929                 :          0 :                         timer->node.expires = ktime_add(timer->node.expires,
     930                 :            :                                                         timer->period);
     931                 :          0 :                         timer->enabled = 1;
     932                 :          0 :                         timerqueue_add(&rtc->timerqueue, &timer->node);
     933                 :          0 :                         trace_rtc_timer_enqueue(timer);
     934                 :            :                 }
     935                 :            :         }
     936                 :            : 
     937                 :            :         /* Set next alarm */
     938         [ #  # ]:          0 :         if (next) {
     939                 :          0 :                 struct rtc_wkalrm alarm;
     940                 :          0 :                 int err;
     941                 :          0 :                 int retry = 3;
     942                 :            : 
     943                 :          0 :                 alarm.time = rtc_ktime_to_tm(next->expires);
     944                 :          0 :                 alarm.enabled = 1;
     945                 :          0 : reprogram:
     946                 :          0 :                 err = __rtc_set_alarm(rtc, &alarm);
     947         [ #  # ]:          0 :                 if (err == -ETIME) {
     948                 :          0 :                         goto again;
     949         [ #  # ]:          0 :                 } else if (err) {
     950         [ #  # ]:          0 :                         if (retry-- > 0)
     951                 :          0 :                                 goto reprogram;
     952                 :            : 
     953                 :          0 :                         timer = container_of(next, struct rtc_timer, node);
     954                 :          0 :                         timerqueue_del(&rtc->timerqueue, &timer->node);
     955                 :          0 :                         trace_rtc_timer_dequeue(timer);
     956                 :          0 :                         timer->enabled = 0;
     957                 :          0 :                         dev_err(&rtc->dev, "__rtc_set_alarm: err=%d\n", err);
     958                 :          0 :                         goto again;
     959                 :            :                 }
     960                 :            :         } else {
     961                 :          0 :                 rtc_alarm_disable(rtc);
     962                 :            :         }
     963                 :            : 
     964                 :          0 :         pm_relax(rtc->dev.parent);
     965                 :          0 :         mutex_unlock(&rtc->ops_lock);
     966                 :          0 : }
     967                 :            : 
     968                 :            : /* rtc_timer_init - Initializes an rtc_timer
     969                 :            :  * @timer: timer to be intiialized
     970                 :            :  * @f: function pointer to be called when timer fires
     971                 :            :  * @rtc: pointer to the rtc_device
     972                 :            :  *
     973                 :            :  * Kernel interface to initializing an rtc_timer.
     974                 :            :  */
     975                 :         33 : void rtc_timer_init(struct rtc_timer *timer, void (*f)(struct rtc_device *r),
     976                 :            :                     struct rtc_device *rtc)
     977                 :            : {
     978                 :         33 :         timerqueue_init(&timer->node);
     979                 :         33 :         timer->enabled = 0;
     980                 :         33 :         timer->func = f;
     981                 :         33 :         timer->rtc = rtc;
     982                 :         33 : }
     983                 :            : 
     984                 :            : /* rtc_timer_start - Sets an rtc_timer to fire in the future
     985                 :            :  * @ rtc: rtc device to be used
     986                 :            :  * @ timer: timer being set
     987                 :            :  * @ expires: time at which to expire the timer
     988                 :            :  * @ period: period that the timer will recur
     989                 :            :  *
     990                 :            :  * Kernel interface to set an rtc_timer
     991                 :            :  */
     992                 :          0 : int rtc_timer_start(struct rtc_device *rtc, struct rtc_timer *timer,
     993                 :            :                     ktime_t expires, ktime_t period)
     994                 :            : {
     995                 :          0 :         int ret = 0;
     996                 :            : 
     997                 :          0 :         mutex_lock(&rtc->ops_lock);
     998         [ #  # ]:          0 :         if (timer->enabled)
     999                 :          0 :                 rtc_timer_remove(rtc, timer);
    1000                 :            : 
    1001                 :          0 :         timer->node.expires = expires;
    1002                 :          0 :         timer->period = period;
    1003                 :            : 
    1004                 :          0 :         ret = rtc_timer_enqueue(rtc, timer);
    1005                 :            : 
    1006                 :          0 :         mutex_unlock(&rtc->ops_lock);
    1007                 :          0 :         return ret;
    1008                 :            : }
    1009                 :            : 
    1010                 :            : /* rtc_timer_cancel - Stops an rtc_timer
    1011                 :            :  * @ rtc: rtc device to be used
    1012                 :            :  * @ timer: timer being set
    1013                 :            :  *
    1014                 :            :  * Kernel interface to cancel an rtc_timer
    1015                 :            :  */
    1016                 :          0 : void rtc_timer_cancel(struct rtc_device *rtc, struct rtc_timer *timer)
    1017                 :            : {
    1018                 :          0 :         mutex_lock(&rtc->ops_lock);
    1019         [ #  # ]:          0 :         if (timer->enabled)
    1020                 :          0 :                 rtc_timer_remove(rtc, timer);
    1021                 :          0 :         mutex_unlock(&rtc->ops_lock);
    1022                 :          0 : }
    1023                 :            : 
    1024                 :            : /**
    1025                 :            :  * rtc_read_offset - Read the amount of rtc offset in parts per billion
    1026                 :            :  * @rtc: rtc device to be used
    1027                 :            :  * @offset: the offset in parts per billion
    1028                 :            :  *
    1029                 :            :  * see below for details.
    1030                 :            :  *
    1031                 :            :  * Kernel interface to read rtc clock offset
    1032                 :            :  * Returns 0 on success, or a negative number on error.
    1033                 :            :  * If read_offset() is not implemented for the rtc, return -EINVAL
    1034                 :            :  */
    1035                 :          0 : int rtc_read_offset(struct rtc_device *rtc, long *offset)
    1036                 :            : {
    1037                 :          0 :         int ret;
    1038                 :            : 
    1039         [ #  # ]:          0 :         if (!rtc->ops)
    1040                 :            :                 return -ENODEV;
    1041                 :            : 
    1042         [ #  # ]:          0 :         if (!rtc->ops->read_offset)
    1043                 :            :                 return -EINVAL;
    1044                 :            : 
    1045                 :          0 :         mutex_lock(&rtc->ops_lock);
    1046                 :          0 :         ret = rtc->ops->read_offset(rtc->dev.parent, offset);
    1047                 :          0 :         mutex_unlock(&rtc->ops_lock);
    1048                 :            : 
    1049                 :          0 :         trace_rtc_read_offset(*offset, ret);
    1050                 :          0 :         return ret;
    1051                 :            : }
    1052                 :            : 
    1053                 :            : /**
    1054                 :            :  * rtc_set_offset - Adjusts the duration of the average second
    1055                 :            :  * @rtc: rtc device to be used
    1056                 :            :  * @offset: the offset in parts per billion
    1057                 :            :  *
    1058                 :            :  * Some rtc's allow an adjustment to the average duration of a second
    1059                 :            :  * to compensate for differences in the actual clock rate due to temperature,
    1060                 :            :  * the crystal, capacitor, etc.
    1061                 :            :  *
    1062                 :            :  * The adjustment applied is as follows:
    1063                 :            :  *   t = t0 * (1 + offset * 1e-9)
    1064                 :            :  * where t0 is the measured length of 1 RTC second with offset = 0
    1065                 :            :  *
    1066                 :            :  * Kernel interface to adjust an rtc clock offset.
    1067                 :            :  * Return 0 on success, or a negative number on error.
    1068                 :            :  * If the rtc offset is not setable (or not implemented), return -EINVAL
    1069                 :            :  */
    1070                 :          0 : int rtc_set_offset(struct rtc_device *rtc, long offset)
    1071                 :            : {
    1072                 :          0 :         int ret;
    1073                 :            : 
    1074         [ #  # ]:          0 :         if (!rtc->ops)
    1075                 :            :                 return -ENODEV;
    1076                 :            : 
    1077         [ #  # ]:          0 :         if (!rtc->ops->set_offset)
    1078                 :            :                 return -EINVAL;
    1079                 :            : 
    1080                 :          0 :         mutex_lock(&rtc->ops_lock);
    1081                 :          0 :         ret = rtc->ops->set_offset(rtc->dev.parent, offset);
    1082                 :          0 :         mutex_unlock(&rtc->ops_lock);
    1083                 :            : 
    1084                 :          0 :         trace_rtc_set_offset(offset, ret);
    1085                 :          0 :         return ret;
    1086                 :            : }

Generated by: LCOV version 1.14