Branch data     Line data    Source code

       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : /*
       3                 :            :  * RTC subsystem, base class
       4                 :            :  *
       5                 :            :  * Copyright (C) 2005 Tower Technologies
       6                 :            :  * Author: Alessandro Zummo <a.zummo@towertech.it>
       7                 :            :  *
       8                 :            :  * class skeleton from drivers/hwmon/hwmon.c
       9                 :            :  */
      10                 :            : 
      11                 :            : #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
      12                 :            : 
      13                 :            : #include <linux/module.h>
      14                 :            : #include <linux/of.h>
      15                 :            : #include <linux/rtc.h>
      16                 :            : #include <linux/kdev_t.h>
      17                 :            : #include <linux/idr.h>
      18                 :            : #include <linux/slab.h>
      19                 :            : #include <linux/workqueue.h>
      20                 :            : 
      21                 :            : #include "rtc-core.h"
      22                 :            : 
      23                 :            : static DEFINE_IDA(rtc_ida);
      24                 :            : struct class *rtc_class;
      25                 :            : 
      26                 :          0 : static void rtc_device_release(struct device *dev)
      27                 :            : {
      28                 :            :         struct rtc_device *rtc = to_rtc_device(dev);
      29                 :            : 
      30                 :          0 :         ida_simple_remove(&rtc_ida, rtc->id);
      31                 :          0 :         kfree(rtc);
      32                 :          0 : }
      33                 :            : 
      34                 :            : #ifdef CONFIG_RTC_HCTOSYS_DEVICE
      35                 :            : /* Result of the last RTC to system clock attempt. */
      36                 :            : int rtc_hctosys_ret = -ENODEV;
      37                 :            : #endif
      38                 :            : 
      39                 :            : #if defined(CONFIG_PM_SLEEP) && defined(CONFIG_RTC_HCTOSYS_DEVICE)
      40                 :            : /*
      41                 :            :  * On suspend(), measure the delta between one RTC and the
      42                 :            :  * system's wall clock; restore it on resume().
      43                 :            :  */
      44                 :            : 
      45                 :            : static struct timespec64 old_rtc, old_system, old_delta;
      46                 :            : 
      47                 :            : static int rtc_suspend(struct device *dev)
      48                 :            : {
      49                 :            :         struct rtc_device       *rtc = to_rtc_device(dev);
      50                 :            :         struct rtc_time         tm;
      51                 :            :         struct timespec64       delta, delta_delta;
      52                 :            :         int err;
      53                 :            : 
      54                 :            :         if (timekeeping_rtc_skipsuspend())
      55                 :            :                 return 0;
      56                 :            : 
      57                 :            :         if (strcmp(dev_name(&rtc->dev), CONFIG_RTC_HCTOSYS_DEVICE) != 0)
      58                 :            :                 return 0;
      59                 :            : 
      60                 :            :         /* snapshot the current RTC and system time at suspend*/
      61                 :            :         err = rtc_read_time(rtc, &tm);
      62                 :            :         if (err < 0) {
      63                 :            :                 pr_debug("%s:  fail to read rtc time\n", dev_name(&rtc->dev));
      64                 :            :                 return 0;
      65                 :            :         }
      66                 :            : 
      67                 :            :         ktime_get_real_ts64(&old_system);
      68                 :            :         old_rtc.tv_sec = rtc_tm_to_time64(&tm);
      69                 :            : 
      70                 :            :         /*
      71                 :            :          * To avoid drift caused by repeated suspend/resumes,
      72                 :            :          * which each can add ~1 second drift error,
      73                 :            :          * try to compensate so the difference in system time
      74                 :            :          * and rtc time stays close to constant.
      75                 :            :          */
      76                 :            :         delta = timespec64_sub(old_system, old_rtc);
      77                 :            :         delta_delta = timespec64_sub(delta, old_delta);
      78                 :            :         if (delta_delta.tv_sec < -2 || delta_delta.tv_sec >= 2) {
      79                 :            :                 /*
      80                 :            :                  * if delta_delta is too large, assume time correction
      81                 :            :                  * has occurred and set old_delta to the current delta.
      82                 :            :                  */
      83                 :            :                 old_delta = delta;
      84                 :            :         } else {
      85                 :            :                 /* Otherwise try to adjust old_system to compensate */
      86                 :            :                 old_system = timespec64_sub(old_system, delta_delta);
      87                 :            :         }
      88                 :            : 
      89                 :            :         return 0;
      90                 :            : }
      91                 :            : 
      92                 :            : static int rtc_resume(struct device *dev)
      93                 :            : {
      94                 :            :         struct rtc_device       *rtc = to_rtc_device(dev);
      95                 :            :         struct rtc_time         tm;
      96                 :            :         struct timespec64       new_system, new_rtc;
      97                 :            :         struct timespec64       sleep_time;
      98                 :            :         int err;
      99                 :            : 
     100                 :            :         if (timekeeping_rtc_skipresume())
     101                 :            :                 return 0;
     102                 :            : 
     103                 :            :         rtc_hctosys_ret = -ENODEV;
     104                 :            :         if (strcmp(dev_name(&rtc->dev), CONFIG_RTC_HCTOSYS_DEVICE) != 0)
     105                 :            :                 return 0;
     106                 :            : 
     107                 :            :         /* snapshot the current rtc and system time at resume */
     108                 :            :         ktime_get_real_ts64(&new_system);
     109                 :            :         err = rtc_read_time(rtc, &tm);
     110                 :            :         if (err < 0) {
     111                 :            :                 pr_debug("%s:  fail to read rtc time\n", dev_name(&rtc->dev));
     112                 :            :                 return 0;
     113                 :            :         }
     114                 :            : 
     115                 :            :         new_rtc.tv_sec = rtc_tm_to_time64(&tm);
     116                 :            :         new_rtc.tv_nsec = 0;
     117                 :            : 
     118                 :            :         if (new_rtc.tv_sec < old_rtc.tv_sec) {
     119                 :            :                 pr_debug("%s:  time travel!\n", dev_name(&rtc->dev));
     120                 :            :                 return 0;
     121                 :            :         }
     122                 :            : 
     123                 :            :         /* calculate the RTC time delta (sleep time)*/
     124                 :            :         sleep_time = timespec64_sub(new_rtc, old_rtc);
     125                 :            : 
     126                 :            :         /*
     127                 :            :          * Since these RTC suspend/resume handlers are not called
     128                 :            :          * at the very end of suspend or the start of resume,
     129                 :            :          * some run-time may pass on either sides of the sleep time
     130                 :            :          * so subtract kernel run-time between rtc_suspend to rtc_resume
     131                 :            :          * to keep things accurate.
     132                 :            :          */
     133                 :            :         sleep_time = timespec64_sub(sleep_time,
     134                 :            :                                     timespec64_sub(new_system, old_system));
     135                 :            : 
     136                 :            :         if (sleep_time.tv_sec >= 0)
     137                 :            :                 timekeeping_inject_sleeptime64(&sleep_time);
     138                 :            :         rtc_hctosys_ret = 0;
     139                 :            :         return 0;
     140                 :            : }
     141                 :            : 
     142                 :            : static SIMPLE_DEV_PM_OPS(rtc_class_dev_pm_ops, rtc_suspend, rtc_resume);
     143                 :            : #define RTC_CLASS_DEV_PM_OPS    (&rtc_class_dev_pm_ops)
     144                 :            : #else
     145                 :            : #define RTC_CLASS_DEV_PM_OPS    NULL
     146                 :            : #endif
     147                 :            : 
     148                 :            : /* Ensure the caller will set the id before releasing the device */
     149                 :          0 : static struct rtc_device *rtc_allocate_device(void)
     150                 :            : {
     151                 :            :         struct rtc_device *rtc;
     152                 :            : 
     153                 :          0 :         rtc = kzalloc(sizeof(*rtc), GFP_KERNEL);
     154                 :          0 :         if (!rtc)
     155                 :            :                 return NULL;
     156                 :            : 
     157                 :          0 :         device_initialize(&rtc->dev);
     158                 :            : 
     159                 :            :         /* Drivers can revise this default after allocating the device. */
     160                 :          0 :         rtc->set_offset_nsec =  NSEC_PER_SEC / 2;
     161                 :            : 
     162                 :          0 :         rtc->irq_freq = 1;
     163                 :          0 :         rtc->max_user_freq = 64;
     164                 :          0 :         rtc->dev.class = rtc_class;
     165                 :          0 :         rtc->dev.groups = rtc_get_dev_attribute_groups();
     166                 :          0 :         rtc->dev.release = rtc_device_release;
     167                 :            : 
     168                 :          0 :         mutex_init(&rtc->ops_lock);
     169                 :          0 :         spin_lock_init(&rtc->irq_lock);
     170                 :          0 :         init_waitqueue_head(&rtc->irq_queue);
     171                 :            : 
     172                 :            :         /* Init timerqueue */
     173                 :            :         timerqueue_init_head(&rtc->timerqueue);
     174                 :          0 :         INIT_WORK(&rtc->irqwork, rtc_timer_do_work);
     175                 :            :         /* Init aie timer */
     176                 :          0 :         rtc_timer_init(&rtc->aie_timer, rtc_aie_update_irq, rtc);
     177                 :            :         /* Init uie timer */
     178                 :          0 :         rtc_timer_init(&rtc->uie_rtctimer, rtc_uie_update_irq, rtc);
     179                 :            :         /* Init pie timer */
     180                 :          0 :         hrtimer_init(&rtc->pie_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
     181                 :          0 :         rtc->pie_timer.function = rtc_pie_update_irq;
     182                 :          0 :         rtc->pie_enabled = 0;
     183                 :            : 
     184                 :          0 :         return rtc;
     185                 :            : }
     186                 :            : 
     187                 :          0 : static int rtc_device_get_id(struct device *dev)
     188                 :            : {
     189                 :            :         int of_id = -1, id = -1;
     190                 :            : 
     191                 :          0 :         if (dev->of_node)
     192                 :          0 :                 of_id = of_alias_get_id(dev->of_node, "rtc");
     193                 :          0 :         else if (dev->parent && dev->parent->of_node)
     194                 :          0 :                 of_id = of_alias_get_id(dev->parent->of_node, "rtc");
     195                 :            : 
     196                 :          0 :         if (of_id >= 0) {
     197                 :          0 :                 id = ida_simple_get(&rtc_ida, of_id, of_id + 1, GFP_KERNEL);
     198                 :          0 :                 if (id < 0)
     199                 :          0 :                         dev_warn(dev, "/aliases ID %d not available\n", of_id);
     200                 :            :         }
     201                 :            : 
     202                 :          0 :         if (id < 0)
     203                 :          0 :                 id = ida_simple_get(&rtc_ida, 0, 0, GFP_KERNEL);
     204                 :            : 
     205                 :          0 :         return id;
     206                 :            : }
     207                 :            : 
     208                 :          0 : static void rtc_device_get_offset(struct rtc_device *rtc)
     209                 :            : {
     210                 :            :         time64_t range_secs;
     211                 :            :         u32 start_year;
     212                 :            :         int ret;
     213                 :            : 
     214                 :            :         /*
     215                 :            :          * If RTC driver did not implement the range of RTC hardware device,
     216                 :            :          * then we can not expand the RTC range by adding or subtracting one
     217                 :            :          * offset.
     218                 :            :          */
     219                 :          0 :         if (rtc->range_min == rtc->range_max)
     220                 :          0 :                 return;
     221                 :            : 
     222                 :          0 :         ret = device_property_read_u32(rtc->dev.parent, "start-year",
     223                 :            :                                        &start_year);
     224                 :          0 :         if (!ret) {
     225                 :          0 :                 rtc->start_secs = mktime64(start_year, 1, 1, 0, 0, 0);
     226                 :          0 :                 rtc->set_start_time = true;
     227                 :            :         }
     228                 :            : 
     229                 :            :         /*
     230                 :            :          * If user did not implement the start time for RTC driver, then no
     231                 :            :          * need to expand the RTC range.
     232                 :            :          */
     233                 :          0 :         if (!rtc->set_start_time)
     234                 :            :                 return;
     235                 :            : 
     236                 :          0 :         range_secs = rtc->range_max - rtc->range_min + 1;
     237                 :            : 
     238                 :            :         /*
     239                 :            :          * If the start_secs is larger than the maximum seconds (rtc->range_max)
     240                 :            :          * supported by RTC hardware or the maximum seconds of new expanded
     241                 :            :          * range (start_secs + rtc->range_max - rtc->range_min) is less than
     242                 :            :          * rtc->range_min, which means the minimum seconds (rtc->range_min) of
     243                 :            :          * RTC hardware will be mapped to start_secs by adding one offset, so
     244                 :            :          * the offset seconds calculation formula should be:
     245                 :            :          * rtc->offset_secs = rtc->start_secs - rtc->range_min;
     246                 :            :          *
     247                 :            :          * If the start_secs is larger than the minimum seconds (rtc->range_min)
     248                 :            :          * supported by RTC hardware, then there is one region is overlapped
     249                 :            :          * between the original RTC hardware range and the new expanded range,
     250                 :            :          * and this overlapped region do not need to be mapped into the new
     251                 :            :          * expanded range due to it is valid for RTC device. So the minimum
     252                 :            :          * seconds of RTC hardware (rtc->range_min) should be mapped to
     253                 :            :          * rtc->range_max + 1, then the offset seconds formula should be:
     254                 :            :          * rtc->offset_secs = rtc->range_max - rtc->range_min + 1;
     255                 :            :          *
     256                 :            :          * If the start_secs is less than the minimum seconds (rtc->range_min),
     257                 :            :          * which is similar to case 2. So the start_secs should be mapped to
     258                 :            :          * start_secs + rtc->range_max - rtc->range_min + 1, then the
     259                 :            :          * offset seconds formula should be:
     260                 :            :          * rtc->offset_secs = -(rtc->range_max - rtc->range_min + 1);
     261                 :            :          *
     262                 :            :          * Otherwise the offset seconds should be 0.
     263                 :            :          */
     264                 :          0 :         if (rtc->start_secs > rtc->range_max ||
     265                 :          0 :             rtc->start_secs + range_secs - 1 < rtc->range_min)
     266                 :          0 :                 rtc->offset_secs = rtc->start_secs - rtc->range_min;
     267                 :          0 :         else if (rtc->start_secs > rtc->range_min)
     268                 :          0 :                 rtc->offset_secs = range_secs;
     269                 :          0 :         else if (rtc->start_secs < rtc->range_min)
     270                 :          0 :                 rtc->offset_secs = -range_secs;
     271                 :            :         else
     272                 :          0 :                 rtc->offset_secs = 0;
     273                 :            : }
     274                 :            : 
     275                 :            : /**
     276                 :            :  * rtc_device_unregister - removes the previously registered RTC class device
     277                 :            :  *
     278                 :            :  * @rtc: the RTC class device to destroy
     279                 :            :  */
     280                 :          0 : static void rtc_device_unregister(struct rtc_device *rtc)
     281                 :            : {
     282                 :          0 :         mutex_lock(&rtc->ops_lock);
     283                 :            :         /*
     284                 :            :          * Remove innards of this RTC, then disable it, before
     285                 :            :          * letting any rtc_class_open() users access it again
     286                 :            :          */
     287                 :          0 :         rtc_proc_del_device(rtc);
     288                 :          0 :         cdev_device_del(&rtc->char_dev, &rtc->dev);
     289                 :          0 :         rtc->ops = NULL;
     290                 :          0 :         mutex_unlock(&rtc->ops_lock);
     291                 :          0 :         put_device(&rtc->dev);
     292                 :          0 : }
     293                 :            : 
     294                 :          0 : static void devm_rtc_release_device(struct device *dev, void *res)
     295                 :            : {
     296                 :          0 :         struct rtc_device *rtc = *(struct rtc_device **)res;
     297                 :            : 
     298                 :          0 :         rtc_nvmem_unregister(rtc);
     299                 :            : 
     300                 :          0 :         if (rtc->registered)
     301                 :          0 :                 rtc_device_unregister(rtc);
     302                 :            :         else
     303                 :          0 :                 put_device(&rtc->dev);
     304                 :          0 : }
     305                 :            : 
     306                 :          0 : struct rtc_device *devm_rtc_allocate_device(struct device *dev)
     307                 :            : {
     308                 :            :         struct rtc_device **ptr, *rtc;
     309                 :            :         int id, err;
     310                 :            : 
     311                 :          0 :         id = rtc_device_get_id(dev);
     312                 :          0 :         if (id < 0)
     313                 :          0 :                 return ERR_PTR(id);
     314                 :            : 
     315                 :            :         ptr = devres_alloc(devm_rtc_release_device, sizeof(*ptr), GFP_KERNEL);
     316                 :          0 :         if (!ptr) {
     317                 :            :                 err = -ENOMEM;
     318                 :            :                 goto exit_ida;
     319                 :            :         }
     320                 :            : 
     321                 :          0 :         rtc = rtc_allocate_device();
     322                 :          0 :         if (!rtc) {
     323                 :            :                 err = -ENOMEM;
     324                 :            :                 goto exit_devres;
     325                 :            :         }
     326                 :            : 
     327                 :          0 :         *ptr = rtc;
     328                 :          0 :         devres_add(dev, ptr);
     329                 :            : 
     330                 :          0 :         rtc->id = id;
     331                 :          0 :         rtc->dev.parent = dev;
     332                 :          0 :         dev_set_name(&rtc->dev, "rtc%d", id);
     333                 :            : 
     334                 :          0 :         return rtc;
     335                 :            : 
     336                 :            : exit_devres:
     337                 :          0 :         devres_free(ptr);
     338                 :            : exit_ida:
     339                 :          0 :         ida_simple_remove(&rtc_ida, id);
     340                 :          0 :         return ERR_PTR(err);
     341                 :            : }
     342                 :            : EXPORT_SYMBOL_GPL(devm_rtc_allocate_device);
     343                 :            : 
     344                 :          0 : int __rtc_register_device(struct module *owner, struct rtc_device *rtc)
     345                 :            : {
     346                 :            :         struct rtc_wkalrm alrm;
     347                 :            :         int err;
     348                 :            : 
     349                 :          0 :         if (!rtc->ops) {
     350                 :            :                 dev_dbg(&rtc->dev, "no ops set\n");
     351                 :            :                 return -EINVAL;
     352                 :            :         }
     353                 :            : 
     354                 :          0 :         rtc->owner = owner;
     355                 :          0 :         rtc_device_get_offset(rtc);
     356                 :            : 
     357                 :            :         /* Check to see if there is an ALARM already set in hw */
     358                 :          0 :         err = __rtc_read_alarm(rtc, &alrm);
     359                 :          0 :         if (!err && !rtc_valid_tm(&alrm.time))
     360                 :          0 :                 rtc_initialize_alarm(rtc, &alrm);
     361                 :            : 
     362                 :          0 :         rtc_dev_prepare(rtc);
     363                 :            : 
     364                 :          0 :         err = cdev_device_add(&rtc->char_dev, &rtc->dev);
     365                 :          0 :         if (err)
     366                 :          0 :                 dev_warn(rtc->dev.parent, "failed to add char device %d:%d\n",
     367                 :            :                          MAJOR(rtc->dev.devt), rtc->id);
     368                 :            :         else
     369                 :            :                 dev_dbg(rtc->dev.parent, "char device (%d:%d)\n",
     370                 :            :                         MAJOR(rtc->dev.devt), rtc->id);
     371                 :            : 
     372                 :          0 :         rtc_proc_add_device(rtc);
     373                 :            : 
     374                 :          0 :         rtc->registered = true;
     375                 :          0 :         dev_info(rtc->dev.parent, "registered as %s\n",
     376                 :            :                  dev_name(&rtc->dev));
     377                 :            : 
     378                 :          0 :         return 0;
     379                 :            : }
     380                 :            : EXPORT_SYMBOL_GPL(__rtc_register_device);
     381                 :            : 
     382                 :            : /**
     383                 :            :  * devm_rtc_device_register - resource managed rtc_device_register()
     384                 :            :  * @dev: the device to register
     385                 :            :  * @name: the name of the device (unused)
     386                 :            :  * @ops: the rtc operations structure
     387                 :            :  * @owner: the module owner
     388                 :            :  *
     389                 :            :  * @return a struct rtc on success, or an ERR_PTR on error
     390                 :            :  *
     391                 :            :  * Managed rtc_device_register(). The rtc_device returned from this function
     392                 :            :  * are automatically freed on driver detach.
     393                 :            :  * This function is deprecated, use devm_rtc_allocate_device and
     394                 :            :  * rtc_register_device instead
     395                 :            :  */
     396                 :          0 : struct rtc_device *devm_rtc_device_register(struct device *dev,
     397                 :            :                                             const char *name,
     398                 :            :                                             const struct rtc_class_ops *ops,
     399                 :            :                                             struct module *owner)
     400                 :            : {
     401                 :            :         struct rtc_device *rtc;
     402                 :            :         int err;
     403                 :            : 
     404                 :          0 :         rtc = devm_rtc_allocate_device(dev);
     405                 :          0 :         if (IS_ERR(rtc))
     406                 :            :                 return rtc;
     407                 :            : 
     408                 :          0 :         rtc->ops = ops;
     409                 :            : 
     410                 :          0 :         err = __rtc_register_device(owner, rtc);
     411                 :          0 :         if (err)
     412                 :          0 :                 return ERR_PTR(err);
     413                 :            : 
     414                 :            :         return rtc;
     415                 :            : }
     416                 :            : EXPORT_SYMBOL_GPL(devm_rtc_device_register);
     417                 :            : 
     418                 :          3 : static int __init rtc_init(void)
     419                 :            : {
     420                 :          3 :         rtc_class = class_create(THIS_MODULE, "rtc");
     421                 :          3 :         if (IS_ERR(rtc_class)) {
     422                 :          0 :                 pr_err("couldn't create class\n");
     423                 :          0 :                 return PTR_ERR(rtc_class);
     424                 :            :         }
     425                 :          3 :         rtc_class->pm = RTC_CLASS_DEV_PM_OPS;
     426                 :          3 :         rtc_dev_init();
     427                 :          3 :         return 0;
     428                 :            : }
     429                 :            : subsys_initcall(rtc_init);