LCOV - code coverage report
Current view: top level - drivers/rtc - interface.c (source / functions) Hit Total Coverage
Test: Real Lines: 10 378 2.6 %
Date: 2020-10-17 15:46:16 Functions: 0 33 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

           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                 :          0 : static void rtc_add_offset(struct rtc_device *rtc, struct rtc_time *tm)
      24                 :            : {
      25                 :            :         time64_t secs;
      26                 :            : 
      27                 :          0 :         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                 :            :         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 :                 time64_t range_max = rtc->set_start_time ?
      74                 :          0 :                         (rtc->start_secs + rtc->range_max - rtc->range_min) :
      75                 :          0 :                         rtc->range_max;
      76                 :            : 
      77                 :          0 :                 if (time < range_min || time > range_max)
      78                 :            :                         return -ERANGE;
      79                 :            :         }
      80                 :            : 
      81                 :            :         return 0;
      82                 :            : }
      83                 :            : 
      84                 :          0 : static int __rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm)
      85                 :            : {
      86                 :            :         int err;
      87                 :            : 
      88                 :          0 :         if (!rtc->ops) {
      89                 :            :                 err = -ENODEV;
      90                 :          0 :         } else if (!rtc->ops->read_time) {
      91                 :            :                 err = -EINVAL;
      92                 :            :         } else {
      93                 :          0 :                 memset(tm, 0, sizeof(struct rtc_time));
      94                 :          0 :                 err = rtc->ops->read_time(rtc->dev.parent, tm);
      95                 :          0 :                 if (err < 0) {
      96                 :            :                         dev_dbg(&rtc->dev, "read_time: fail to read: %d\n",
      97                 :            :                                 err);
      98                 :            :                         return err;
      99                 :            :                 }
     100                 :            : 
     101                 :          0 :                 rtc_add_offset(rtc, tm);
     102                 :            : 
     103                 :          0 :                 err = rtc_valid_tm(tm);
     104                 :            :                 if (err < 0)
     105                 :            :                         dev_dbg(&rtc->dev, "read_time: rtc_time isn't valid\n");
     106                 :            :         }
     107                 :          0 :         return err;
     108                 :            : }
     109                 :            : 
     110                 :          0 : int rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm)
     111                 :            : {
     112                 :            :         int err;
     113                 :            : 
     114                 :          0 :         err = mutex_lock_interruptible(&rtc->ops_lock);
     115                 :          0 :         if (err)
     116                 :            :                 return err;
     117                 :            : 
     118                 :          0 :         err = __rtc_read_time(rtc, tm);
     119                 :          0 :         mutex_unlock(&rtc->ops_lock);
     120                 :            : 
     121                 :          0 :         trace_rtc_read_time(rtc_tm_to_time64(tm), err);
     122                 :          0 :         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                 :            :         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                 :            :         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                 :          0 : static int rtc_read_alarm_internal(struct rtc_device *rtc,
     179                 :            :                                    struct rtc_wkalrm *alarm)
     180                 :            : {
     181                 :            :         int err;
     182                 :            : 
     183                 :          0 :         err = mutex_lock_interruptible(&rtc->ops_lock);
     184                 :          0 :         if (err)
     185                 :            :                 return err;
     186                 :            : 
     187                 :          0 :         if (!rtc->ops) {
     188                 :            :                 err = -ENODEV;
     189                 :          0 :         } else if (!rtc->ops->read_alarm) {
     190                 :            :                 err = -EINVAL;
     191                 :            :         } else {
     192                 :          0 :                 alarm->enabled = 0;
     193                 :          0 :                 alarm->pending = 0;
     194                 :          0 :                 alarm->time.tm_sec = -1;
     195                 :          0 :                 alarm->time.tm_min = -1;
     196                 :          0 :                 alarm->time.tm_hour = -1;
     197                 :          0 :                 alarm->time.tm_mday = -1;
     198                 :          0 :                 alarm->time.tm_mon = -1;
     199                 :          0 :                 alarm->time.tm_year = -1;
     200                 :          0 :                 alarm->time.tm_wday = -1;
     201                 :          0 :                 alarm->time.tm_yday = -1;
     202                 :          0 :                 alarm->time.tm_isdst = -1;
     203                 :          0 :                 err = rtc->ops->read_alarm(rtc->dev.parent, alarm);
     204                 :            :         }
     205                 :            : 
     206                 :          0 :         mutex_unlock(&rtc->ops_lock);
     207                 :            : 
     208                 :          0 :         trace_rtc_read_alarm(rtc_tm_to_time64(&alarm->time), err);
     209                 :          0 :         return err;
     210                 :            : }
     211                 :            : 
     212                 :          0 : int __rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
     213                 :            : {
     214                 :            :         int err;
     215                 :            :         struct rtc_time before, now;
     216                 :            :         int first_time = 1;
     217                 :            :         time64_t t_now, t_alm;
     218                 :            :         enum { none, day, month, year } missing = none;
     219                 :            :         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                 :          0 :         err = rtc_read_time(rtc, &before);
     264                 :          0 :         if (err < 0)
     265                 :            :                 return err;
     266                 :            :         do {
     267                 :          0 :                 if (!first_time)
     268                 :          0 :                         memcpy(&before, &now, sizeof(struct rtc_time));
     269                 :            :                 first_time = 0;
     270                 :            : 
     271                 :            :                 /* get the RTC alarm values, which may be incomplete */
     272                 :          0 :                 err = rtc_read_alarm_internal(rtc, alarm);
     273                 :          0 :                 if (err)
     274                 :          0 :                         return err;
     275                 :            : 
     276                 :            :                 /* full-function RTCs won't have such missing fields */
     277                 :          0 :                 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                 :          0 :                 err = rtc_read_time(rtc, &now);
     284                 :          0 :                 if (err < 0)
     285                 :          0 :                         return err;
     286                 :            : 
     287                 :            :                 /* note that tm_sec is a "don't care" value here: */
     288                 :          0 :         } while (before.tm_min  != now.tm_min ||
     289                 :          0 :                  before.tm_hour != now.tm_hour ||
     290                 :          0 :                  before.tm_mon  != now.tm_mon ||
     291                 :          0 :                  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                 :          0 :         if (alarm->time.tm_sec == -1)
     297                 :          0 :                 alarm->time.tm_sec = now.tm_sec;
     298                 :          0 :         if (alarm->time.tm_min == -1)
     299                 :          0 :                 alarm->time.tm_min = now.tm_min;
     300                 :          0 :         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                 :          0 :         if (alarm->time.tm_mday < 1 || alarm->time.tm_mday > 31) {
     305                 :          0 :                 alarm->time.tm_mday = now.tm_mday;
     306                 :            :                 missing = day;
     307                 :            :         }
     308                 :          0 :         if ((unsigned int)alarm->time.tm_mon >= 12) {
     309                 :          0 :                 alarm->time.tm_mon = now.tm_mon;
     310                 :          0 :                 if (missing == none)
     311                 :            :                         missing = month;
     312                 :            :         }
     313                 :          0 :         if (alarm->time.tm_year == -1) {
     314                 :          0 :                 alarm->time.tm_year = now.tm_year;
     315                 :          0 :                 if (missing == none)
     316                 :            :                         missing = year;
     317                 :            :         }
     318                 :            : 
     319                 :            :         /* Can't proceed if alarm is still invalid after replacing
     320                 :            :          * missing fields.
     321                 :            :          */
     322                 :          0 :         err = rtc_valid_tm(&alarm->time);
     323                 :          0 :         if (err)
     324                 :            :                 goto done;
     325                 :            : 
     326                 :            :         /* with luck, no rollover is needed */
     327                 :          0 :         t_now = rtc_tm_to_time64(&now);
     328                 :          0 :         t_alm = rtc_tm_to_time64(&alarm->time);
     329                 :          0 :         if (t_now < t_alm)
     330                 :            :                 goto done;
     331                 :            : 
     332                 :          0 :         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                 :            :                 dev_dbg(&rtc->dev, "alarm rollover: %s\n", "day");
     340                 :          0 :                 t_alm += 24 * 60 * 60;
     341                 :          0 :                 rtc_time64_to_tm(t_alm, &alarm->time);
     342                 :          0 :                 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                 :            :                 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                 :            :                 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                 :            :         default:
     373                 :          0 :                 dev_warn(&rtc->dev, "alarm rollover not handled\n");
     374                 :            :         }
     375                 :            : 
     376                 :          0 :         err = rtc_valid_tm(&alarm->time);
     377                 :            : 
     378                 :            : done:
     379                 :          0 :         if (err)
     380                 :          0 :                 dev_warn(&rtc->dev, "invalid alarm value: %ptR\n",
     381                 :            :                          &alarm->time);
     382                 :            : 
     383                 :          0 :         return err;
     384                 :            : }
     385                 :            : 
     386                 :          0 : int rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
     387                 :            : {
     388                 :            :         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                 :            :         struct rtc_time tm;
     412                 :            :         time64_t now, scheduled;
     413                 :            :         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                 :            :         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                 :          0 : int rtc_initialize_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
     484                 :            : {
     485                 :            :         int err;
     486                 :            :         struct rtc_time now;
     487                 :            : 
     488                 :          0 :         err = rtc_valid_tm(&alarm->time);
     489                 :          0 :         if (err != 0)
     490                 :            :                 return err;
     491                 :            : 
     492                 :          0 :         err = rtc_read_time(rtc, &now);
     493                 :          0 :         if (err)
     494                 :            :                 return err;
     495                 :            : 
     496                 :          0 :         err = mutex_lock_interruptible(&rtc->ops_lock);
     497                 :          0 :         if (err)
     498                 :            :                 return err;
     499                 :            : 
     500                 :          0 :         rtc->aie_timer.node.expires = rtc_tm_to_ktime(alarm->time);
     501                 :          0 :         rtc->aie_timer.period = 0;
     502                 :            : 
     503                 :            :         /* Alarm has to be enabled & in the future for us to enqueue it */
     504                 :          0 :         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                 :          0 :         mutex_unlock(&rtc->ops_lock);
     511                 :          0 :         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                 :            :         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                 :            :         int 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                 :            :                 goto out;
     563                 :            : 
     564                 :          0 :         if (rtc->uie_unsupported) {
     565                 :            :                 err = -EINVAL;
     566                 :            :                 goto out;
     567                 :            :         }
     568                 :            : 
     569                 :          0 :         if (enabled) {
     570                 :            :                 struct rtc_time tm;
     571                 :            :                 ktime_t now, onesec;
     572                 :            : 
     573                 :          0 :                 __rtc_read_time(rtc, &tm);
     574                 :            :                 onesec = ktime_set(1, 0);
     575                 :          0 :                 now = rtc_tm_to_ktime(tm);
     576                 :          0 :                 rtc->uie_rtctimer.node.expires = ktime_add(now, onesec);
     577                 :          0 :                 rtc->uie_rtctimer.period = ktime_set(1, 0);
     578                 :          0 :                 err = rtc_timer_enqueue(rtc, &rtc->uie_rtctimer);
     579                 :            :         } else {
     580                 :          0 :                 rtc_timer_remove(rtc, &rtc->uie_rtctimer);
     581                 :            :         }
     582                 :            : 
     583                 :            : out:
     584                 :          0 :         mutex_unlock(&rtc->ops_lock);
     585                 :            : #ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
     586                 :            :         /*
     587                 :            :          * Enable emulation if the driver returned -EINVAL to signal that it has
     588                 :            :          * been configured without interrupts or they are not available at the
     589                 :            :          * moment.
     590                 :            :          */
     591                 :            :         if (err == -EINVAL)
     592                 :            :                 err = rtc_dev_update_irq_enable_emul(rtc, enabled);
     593                 :            : #endif
     594                 :          0 :         return err;
     595                 :            : }
     596                 :            : EXPORT_SYMBOL_GPL(rtc_update_irq_enable);
     597                 :            : 
     598                 :            : /**
     599                 :            :  * rtc_handle_legacy_irq - AIE, UIE and PIE event hook
     600                 :            :  * @rtc: pointer to the rtc device
     601                 :            :  *
     602                 :            :  * This function is called when an AIE, UIE or PIE mode interrupt
     603                 :            :  * has occurred (or been emulated).
     604                 :            :  *
     605                 :            :  */
     606                 :          0 : void rtc_handle_legacy_irq(struct rtc_device *rtc, int num, int mode)
     607                 :            : {
     608                 :            :         unsigned long flags;
     609                 :            : 
     610                 :            :         /* mark one irq of the appropriate mode */
     611                 :          0 :         spin_lock_irqsave(&rtc->irq_lock, flags);
     612                 :          0 :         rtc->irq_data = (rtc->irq_data + (num << 8)) | (RTC_IRQF | mode);
     613                 :            :         spin_unlock_irqrestore(&rtc->irq_lock, flags);
     614                 :            : 
     615                 :          0 :         wake_up_interruptible(&rtc->irq_queue);
     616                 :          0 :         kill_fasync(&rtc->async_queue, SIGIO, POLL_IN);
     617                 :          0 : }
     618                 :            : 
     619                 :            : /**
     620                 :            :  * rtc_aie_update_irq - AIE mode rtctimer hook
     621                 :            :  * @rtc: pointer to the rtc_device
     622                 :            :  *
     623                 :            :  * This functions is called when the aie_timer expires.
     624                 :            :  */
     625                 :          0 : void rtc_aie_update_irq(struct rtc_device *rtc)
     626                 :            : {
     627                 :          0 :         rtc_handle_legacy_irq(rtc, 1, RTC_AF);
     628                 :          0 : }
     629                 :            : 
     630                 :            : /**
     631                 :            :  * rtc_uie_update_irq - UIE mode rtctimer hook
     632                 :            :  * @rtc: pointer to the rtc_device
     633                 :            :  *
     634                 :            :  * This functions is called when the uie_timer expires.
     635                 :            :  */
     636                 :          0 : void rtc_uie_update_irq(struct rtc_device *rtc)
     637                 :            : {
     638                 :          0 :         rtc_handle_legacy_irq(rtc, 1,  RTC_UF);
     639                 :          0 : }
     640                 :            : 
     641                 :            : /**
     642                 :            :  * rtc_pie_update_irq - PIE mode hrtimer hook
     643                 :            :  * @timer: pointer to the pie mode hrtimer
     644                 :            :  *
     645                 :            :  * This function is used to emulate PIE mode interrupts
     646                 :            :  * using an hrtimer. This function is called when the periodic
     647                 :            :  * hrtimer expires.
     648                 :            :  */
     649                 :          0 : enum hrtimer_restart rtc_pie_update_irq(struct hrtimer *timer)
     650                 :            : {
     651                 :            :         struct rtc_device *rtc;
     652                 :            :         ktime_t period;
     653                 :            :         u64 count;
     654                 :            : 
     655                 :          0 :         rtc = container_of(timer, struct rtc_device, pie_timer);
     656                 :            : 
     657                 :          0 :         period = NSEC_PER_SEC / rtc->irq_freq;
     658                 :          0 :         count = hrtimer_forward_now(timer, period);
     659                 :            : 
     660                 :          0 :         rtc_handle_legacy_irq(rtc, count, RTC_PF);
     661                 :            : 
     662                 :          0 :         return HRTIMER_RESTART;
     663                 :            : }
     664                 :            : 
     665                 :            : /**
     666                 :            :  * rtc_update_irq - Triggered when a RTC interrupt occurs.
     667                 :            :  * @rtc: the rtc device
     668                 :            :  * @num: how many irqs are being reported (usually one)
     669                 :            :  * @events: mask of RTC_IRQF with one or more of RTC_PF, RTC_AF, RTC_UF
     670                 :            :  * Context: any
     671                 :            :  */
     672                 :          0 : void rtc_update_irq(struct rtc_device *rtc,
     673                 :            :                     unsigned long num, unsigned long events)
     674                 :            : {
     675                 :          0 :         if (IS_ERR_OR_NULL(rtc))
     676                 :          0 :                 return;
     677                 :            : 
     678                 :            :         pm_stay_awake(rtc->dev.parent);
     679                 :          0 :         schedule_work(&rtc->irqwork);
     680                 :            : }
     681                 :            : EXPORT_SYMBOL_GPL(rtc_update_irq);
     682                 :            : 
     683                 :          3 : struct rtc_device *rtc_class_open(const char *name)
     684                 :            : {
     685                 :            :         struct device *dev;
     686                 :            :         struct rtc_device *rtc = NULL;
     687                 :            : 
     688                 :          3 :         dev = class_find_device_by_name(rtc_class, name);
     689                 :          3 :         if (dev)
     690                 :            :                 rtc = to_rtc_device(dev);
     691                 :            : 
     692                 :          3 :         if (rtc) {
     693                 :          0 :                 if (!try_module_get(rtc->owner)) {
     694                 :          0 :                         put_device(dev);
     695                 :            :                         rtc = NULL;
     696                 :            :                 }
     697                 :            :         }
     698                 :            : 
     699                 :          3 :         return rtc;
     700                 :            : }
     701                 :            : EXPORT_SYMBOL_GPL(rtc_class_open);
     702                 :            : 
     703                 :          0 : void rtc_class_close(struct rtc_device *rtc)
     704                 :            : {
     705                 :          0 :         module_put(rtc->owner);
     706                 :          0 :         put_device(&rtc->dev);
     707                 :          0 : }
     708                 :            : EXPORT_SYMBOL_GPL(rtc_class_close);
     709                 :            : 
     710                 :          0 : static int rtc_update_hrtimer(struct rtc_device *rtc, int enabled)
     711                 :            : {
     712                 :            :         /*
     713                 :            :          * We always cancel the timer here first, because otherwise
     714                 :            :          * we could run into BUG_ON(timer->state != HRTIMER_STATE_CALLBACK);
     715                 :            :          * when we manage to start the timer before the callback
     716                 :            :          * returns HRTIMER_RESTART.
     717                 :            :          *
     718                 :            :          * We cannot use hrtimer_cancel() here as a running callback
     719                 :            :          * could be blocked on rtc->irq_task_lock and hrtimer_cancel()
     720                 :            :          * would spin forever.
     721                 :            :          */
     722                 :          0 :         if (hrtimer_try_to_cancel(&rtc->pie_timer) < 0)
     723                 :            :                 return -1;
     724                 :            : 
     725                 :          0 :         if (enabled) {
     726                 :          0 :                 ktime_t period = NSEC_PER_SEC / rtc->irq_freq;
     727                 :            : 
     728                 :            :                 hrtimer_start(&rtc->pie_timer, period, HRTIMER_MODE_REL);
     729                 :            :         }
     730                 :            :         return 0;
     731                 :            : }
     732                 :            : 
     733                 :            : /**
     734                 :            :  * rtc_irq_set_state - enable/disable 2^N Hz periodic IRQs
     735                 :            :  * @rtc: the rtc device
     736                 :            :  * @enabled: true to enable periodic IRQs
     737                 :            :  * Context: any
     738                 :            :  *
     739                 :            :  * Note that rtc_irq_set_freq() should previously have been used to
     740                 :            :  * specify the desired frequency of periodic IRQ.
     741                 :            :  */
     742                 :          0 : int rtc_irq_set_state(struct rtc_device *rtc, int enabled)
     743                 :            : {
     744                 :            :         int err = 0;
     745                 :            : 
     746                 :          0 :         while (rtc_update_hrtimer(rtc, enabled) < 0)
     747                 :          0 :                 cpu_relax();
     748                 :            : 
     749                 :          0 :         rtc->pie_enabled = enabled;
     750                 :            : 
     751                 :          0 :         trace_rtc_irq_set_state(enabled, err);
     752                 :          0 :         return err;
     753                 :            : }
     754                 :            : 
     755                 :            : /**
     756                 :            :  * rtc_irq_set_freq - set 2^N Hz periodic IRQ frequency for IRQ
     757                 :            :  * @rtc: the rtc device
     758                 :            :  * @freq: positive frequency
     759                 :            :  * Context: any
     760                 :            :  *
     761                 :            :  * Note that rtc_irq_set_state() is used to enable or disable the
     762                 :            :  * periodic IRQs.
     763                 :            :  */
     764                 :          0 : int rtc_irq_set_freq(struct rtc_device *rtc, int freq)
     765                 :            : {
     766                 :            :         int err = 0;
     767                 :            : 
     768                 :          0 :         if (freq <= 0 || freq > RTC_MAX_FREQ)
     769                 :            :                 return -EINVAL;
     770                 :            : 
     771                 :          0 :         rtc->irq_freq = freq;
     772                 :          0 :         while (rtc->pie_enabled && rtc_update_hrtimer(rtc, 1) < 0)
     773                 :          0 :                 cpu_relax();
     774                 :            : 
     775                 :          0 :         trace_rtc_irq_set_freq(freq, err);
     776                 :          0 :         return err;
     777                 :            : }
     778                 :            : 
     779                 :            : /**
     780                 :            :  * rtc_timer_enqueue - Adds a rtc_timer to the rtc_device timerqueue
     781                 :            :  * @rtc rtc device
     782                 :            :  * @timer timer being added.
     783                 :            :  *
     784                 :            :  * Enqueues a timer onto the rtc devices timerqueue and sets
     785                 :            :  * the next alarm event appropriately.
     786                 :            :  *
     787                 :            :  * Sets the enabled bit on the added timer.
     788                 :            :  *
     789                 :            :  * Must hold ops_lock for proper serialization of timerqueue
     790                 :            :  */
     791                 :          0 : static int rtc_timer_enqueue(struct rtc_device *rtc, struct rtc_timer *timer)
     792                 :            : {
     793                 :            :         struct timerqueue_node *next = timerqueue_getnext(&rtc->timerqueue);
     794                 :            :         struct rtc_time tm;
     795                 :            :         ktime_t now;
     796                 :            : 
     797                 :          0 :         timer->enabled = 1;
     798                 :          0 :         __rtc_read_time(rtc, &tm);
     799                 :          0 :         now = rtc_tm_to_ktime(tm);
     800                 :            : 
     801                 :            :         /* Skip over expired timers */
     802                 :          0 :         while (next) {
     803                 :          0 :                 if (next->expires >= now)
     804                 :            :                         break;
     805                 :          0 :                 next = timerqueue_iterate_next(next);
     806                 :            :         }
     807                 :            : 
     808                 :          0 :         timerqueue_add(&rtc->timerqueue, &timer->node);
     809                 :          0 :         trace_rtc_timer_enqueue(timer);
     810                 :          0 :         if (!next || ktime_before(timer->node.expires, next->expires)) {
     811                 :            :                 struct rtc_wkalrm alarm;
     812                 :            :                 int err;
     813                 :            : 
     814                 :          0 :                 alarm.time = rtc_ktime_to_tm(timer->node.expires);
     815                 :          0 :                 alarm.enabled = 1;
     816                 :          0 :                 err = __rtc_set_alarm(rtc, &alarm);
     817                 :          0 :                 if (err == -ETIME) {
     818                 :            :                         pm_stay_awake(rtc->dev.parent);
     819                 :          0 :                         schedule_work(&rtc->irqwork);
     820                 :          0 :                 } else if (err) {
     821                 :          0 :                         timerqueue_del(&rtc->timerqueue, &timer->node);
     822                 :          0 :                         trace_rtc_timer_dequeue(timer);
     823                 :          0 :                         timer->enabled = 0;
     824                 :          0 :                         return err;
     825                 :            :                 }
     826                 :            :         }
     827                 :            :         return 0;
     828                 :            : }
     829                 :            : 
     830                 :          0 : static void rtc_alarm_disable(struct rtc_device *rtc)
     831                 :            : {
     832                 :          0 :         if (!rtc->ops || !rtc->ops->alarm_irq_enable)
     833                 :          0 :                 return;
     834                 :            : 
     835                 :          0 :         rtc->ops->alarm_irq_enable(rtc->dev.parent, false);
     836                 :          0 :         trace_rtc_alarm_irq_enable(0, 0);
     837                 :            : }
     838                 :            : 
     839                 :            : /**
     840                 :            :  * rtc_timer_remove - Removes a rtc_timer from the rtc_device timerqueue
     841                 :            :  * @rtc rtc device
     842                 :            :  * @timer timer being removed.
     843                 :            :  *
     844                 :            :  * Removes a timer onto the rtc devices timerqueue and sets
     845                 :            :  * the next alarm event appropriately.
     846                 :            :  *
     847                 :            :  * Clears the enabled bit on the removed timer.
     848                 :            :  *
     849                 :            :  * Must hold ops_lock for proper serialization of timerqueue
     850                 :            :  */
     851                 :          0 : static void rtc_timer_remove(struct rtc_device *rtc, struct rtc_timer *timer)
     852                 :            : {
     853                 :            :         struct timerqueue_node *next = timerqueue_getnext(&rtc->timerqueue);
     854                 :            : 
     855                 :          0 :         timerqueue_del(&rtc->timerqueue, &timer->node);
     856                 :          0 :         trace_rtc_timer_dequeue(timer);
     857                 :          0 :         timer->enabled = 0;
     858                 :          0 :         if (next == &timer->node) {
     859                 :            :                 struct rtc_wkalrm alarm;
     860                 :            :                 int err;
     861                 :            : 
     862                 :            :                 next = timerqueue_getnext(&rtc->timerqueue);
     863                 :          0 :                 if (!next) {
     864                 :          0 :                         rtc_alarm_disable(rtc);
     865                 :          0 :                         return;
     866                 :            :                 }
     867                 :          0 :                 alarm.time = rtc_ktime_to_tm(next->expires);
     868                 :          0 :                 alarm.enabled = 1;
     869                 :          0 :                 err = __rtc_set_alarm(rtc, &alarm);
     870                 :          0 :                 if (err == -ETIME) {
     871                 :            :                         pm_stay_awake(rtc->dev.parent);
     872                 :          0 :                         schedule_work(&rtc->irqwork);
     873                 :            :                 }
     874                 :            :         }
     875                 :            : }
     876                 :            : 
     877                 :            : /**
     878                 :            :  * rtc_timer_do_work - Expires rtc timers
     879                 :            :  * @rtc rtc device
     880                 :            :  * @timer timer being removed.
     881                 :            :  *
     882                 :            :  * Expires rtc timers. Reprograms next alarm event if needed.
     883                 :            :  * Called via worktask.
     884                 :            :  *
     885                 :            :  * Serializes access to timerqueue via ops_lock mutex
     886                 :            :  */
     887                 :          0 : void rtc_timer_do_work(struct work_struct *work)
     888                 :            : {
     889                 :            :         struct rtc_timer *timer;
     890                 :            :         struct timerqueue_node *next;
     891                 :            :         ktime_t now;
     892                 :            :         struct rtc_time tm;
     893                 :            : 
     894                 :            :         struct rtc_device *rtc =
     895                 :          0 :                 container_of(work, struct rtc_device, irqwork);
     896                 :            : 
     897                 :          0 :         mutex_lock(&rtc->ops_lock);
     898                 :            : again:
     899                 :          0 :         __rtc_read_time(rtc, &tm);
     900                 :          0 :         now = rtc_tm_to_ktime(tm);
     901                 :          0 :         while ((next = timerqueue_getnext(&rtc->timerqueue))) {
     902                 :          0 :                 if (next->expires > now)
     903                 :            :                         break;
     904                 :            : 
     905                 :            :                 /* expire timer */
     906                 :            :                 timer = container_of(next, struct rtc_timer, node);
     907                 :          0 :                 timerqueue_del(&rtc->timerqueue, &timer->node);
     908                 :          0 :                 trace_rtc_timer_dequeue(timer);
     909                 :          0 :                 timer->enabled = 0;
     910                 :          0 :                 if (timer->func)
     911                 :          0 :                         timer->func(timer->rtc);
     912                 :            : 
     913                 :          0 :                 trace_rtc_timer_fired(timer);
     914                 :            :                 /* Re-add/fwd periodic timers */
     915                 :          0 :                 if (ktime_to_ns(timer->period)) {
     916                 :          0 :                         timer->node.expires = ktime_add(timer->node.expires,
     917                 :            :                                                         timer->period);
     918                 :          0 :                         timer->enabled = 1;
     919                 :          0 :                         timerqueue_add(&rtc->timerqueue, &timer->node);
     920                 :          0 :                         trace_rtc_timer_enqueue(timer);
     921                 :            :                 }
     922                 :            :         }
     923                 :            : 
     924                 :            :         /* Set next alarm */
     925                 :          0 :         if (next) {
     926                 :            :                 struct rtc_wkalrm alarm;
     927                 :            :                 int err;
     928                 :            :                 int retry = 3;
     929                 :            : 
     930                 :          0 :                 alarm.time = rtc_ktime_to_tm(next->expires);
     931                 :          0 :                 alarm.enabled = 1;
     932                 :            : reprogram:
     933                 :          0 :                 err = __rtc_set_alarm(rtc, &alarm);
     934                 :          0 :                 if (err == -ETIME) {
     935                 :            :                         goto again;
     936                 :          0 :                 } else if (err) {
     937                 :          0 :                         if (retry-- > 0)
     938                 :            :                                 goto reprogram;
     939                 :            : 
     940                 :          0 :                         timer = container_of(next, struct rtc_timer, node);
     941                 :          0 :                         timerqueue_del(&rtc->timerqueue, &timer->node);
     942                 :          0 :                         trace_rtc_timer_dequeue(timer);
     943                 :          0 :                         timer->enabled = 0;
     944                 :          0 :                         dev_err(&rtc->dev, "__rtc_set_alarm: err=%d\n", err);
     945                 :          0 :                         goto again;
     946                 :            :                 }
     947                 :            :         } else {
     948                 :          0 :                 rtc_alarm_disable(rtc);
     949                 :            :         }
     950                 :            : 
     951                 :            :         pm_relax(rtc->dev.parent);
     952                 :          0 :         mutex_unlock(&rtc->ops_lock);
     953                 :          0 : }
     954                 :            : 
     955                 :            : /* rtc_timer_init - Initializes an rtc_timer
     956                 :            :  * @timer: timer to be intiialized
     957                 :            :  * @f: function pointer to be called when timer fires
     958                 :            :  * @rtc: pointer to the rtc_device
     959                 :            :  *
     960                 :            :  * Kernel interface to initializing an rtc_timer.
     961                 :            :  */
     962                 :          3 : void rtc_timer_init(struct rtc_timer *timer, void (*f)(struct rtc_device *r),
     963                 :            :                     struct rtc_device *rtc)
     964                 :            : {
     965                 :            :         timerqueue_init(&timer->node);
     966                 :          3 :         timer->enabled = 0;
     967                 :          3 :         timer->func = f;
     968                 :          3 :         timer->rtc = rtc;
     969                 :          3 : }
     970                 :            : 
     971                 :            : /* rtc_timer_start - Sets an rtc_timer to fire in the future
     972                 :            :  * @ rtc: rtc device to be used
     973                 :            :  * @ timer: timer being set
     974                 :            :  * @ expires: time at which to expire the timer
     975                 :            :  * @ period: period that the timer will recur
     976                 :            :  *
     977                 :            :  * Kernel interface to set an rtc_timer
     978                 :            :  */
     979                 :          0 : int rtc_timer_start(struct rtc_device *rtc, struct rtc_timer *timer,
     980                 :            :                     ktime_t expires, ktime_t period)
     981                 :            : {
     982                 :            :         int ret = 0;
     983                 :            : 
     984                 :          0 :         mutex_lock(&rtc->ops_lock);
     985                 :          0 :         if (timer->enabled)
     986                 :          0 :                 rtc_timer_remove(rtc, timer);
     987                 :            : 
     988                 :          0 :         timer->node.expires = expires;
     989                 :          0 :         timer->period = period;
     990                 :            : 
     991                 :          0 :         ret = rtc_timer_enqueue(rtc, timer);
     992                 :            : 
     993                 :          0 :         mutex_unlock(&rtc->ops_lock);
     994                 :          0 :         return ret;
     995                 :            : }
     996                 :            : 
     997                 :            : /* rtc_timer_cancel - Stops an rtc_timer
     998                 :            :  * @ rtc: rtc device to be used
     999                 :            :  * @ timer: timer being set
    1000                 :            :  *
    1001                 :            :  * Kernel interface to cancel an rtc_timer
    1002                 :            :  */
    1003                 :          0 : void rtc_timer_cancel(struct rtc_device *rtc, struct rtc_timer *timer)
    1004                 :            : {
    1005                 :          0 :         mutex_lock(&rtc->ops_lock);
    1006                 :          0 :         if (timer->enabled)
    1007                 :          0 :                 rtc_timer_remove(rtc, timer);
    1008                 :          0 :         mutex_unlock(&rtc->ops_lock);
    1009                 :          0 : }
    1010                 :            : 
    1011                 :            : /**
    1012                 :            :  * rtc_read_offset - Read the amount of rtc offset in parts per billion
    1013                 :            :  * @ rtc: rtc device to be used
    1014                 :            :  * @ offset: the offset in parts per billion
    1015                 :            :  *
    1016                 :            :  * see below for details.
    1017                 :            :  *
    1018                 :            :  * Kernel interface to read rtc clock offset
    1019                 :            :  * Returns 0 on success, or a negative number on error.
    1020                 :            :  * If read_offset() is not implemented for the rtc, return -EINVAL
    1021                 :            :  */
    1022                 :          0 : int rtc_read_offset(struct rtc_device *rtc, long *offset)
    1023                 :            : {
    1024                 :            :         int ret;
    1025                 :            : 
    1026                 :          0 :         if (!rtc->ops)
    1027                 :            :                 return -ENODEV;
    1028                 :            : 
    1029                 :          0 :         if (!rtc->ops->read_offset)
    1030                 :            :                 return -EINVAL;
    1031                 :            : 
    1032                 :          0 :         mutex_lock(&rtc->ops_lock);
    1033                 :          0 :         ret = rtc->ops->read_offset(rtc->dev.parent, offset);
    1034                 :          0 :         mutex_unlock(&rtc->ops_lock);
    1035                 :            : 
    1036                 :          0 :         trace_rtc_read_offset(*offset, ret);
    1037                 :          0 :         return ret;
    1038                 :            : }
    1039                 :            : 
    1040                 :            : /**
    1041                 :            :  * rtc_set_offset - Adjusts the duration of the average second
    1042                 :            :  * @ rtc: rtc device to be used
    1043                 :            :  * @ offset: the offset in parts per billion
    1044                 :            :  *
    1045                 :            :  * Some rtc's allow an adjustment to the average duration of a second
    1046                 :            :  * to compensate for differences in the actual clock rate due to temperature,
    1047                 :            :  * the crystal, capacitor, etc.
    1048                 :            :  *
    1049                 :            :  * The adjustment applied is as follows:
    1050                 :            :  *   t = t0 * (1 + offset * 1e-9)
    1051                 :            :  * where t0 is the measured length of 1 RTC second with offset = 0
    1052                 :            :  *
    1053                 :            :  * Kernel interface to adjust an rtc clock offset.
    1054                 :            :  * Return 0 on success, or a negative number on error.
    1055                 :            :  * If the rtc offset is not setable (or not implemented), return -EINVAL
    1056                 :            :  */
    1057                 :          0 : int rtc_set_offset(struct rtc_device *rtc, long offset)
    1058                 :            : {
    1059                 :            :         int ret;
    1060                 :            : 
    1061                 :          0 :         if (!rtc->ops)
    1062                 :            :                 return -ENODEV;
    1063                 :            : 
    1064                 :          0 :         if (!rtc->ops->set_offset)
    1065                 :            :                 return -EINVAL;
    1066                 :            : 
    1067                 :          0 :         mutex_lock(&rtc->ops_lock);
    1068                 :          0 :         ret = rtc->ops->set_offset(rtc->dev.parent, offset);
    1069                 :          0 :         mutex_unlock(&rtc->ops_lock);
    1070                 :            : 
    1071                 :          0 :         trace_rtc_set_offset(offset, ret);
    1072                 :          0 :         return ret;
    1073                 :            : }
    

Generated by: LCOV version 1.14