LCOV - code coverage report
Current view: top level - drivers/rtc - dev.c (source / functions) Hit Total Coverage
Test: Real Lines: 4 131 3.1 %
Date: 2020-10-17 15:46:16 Functions: 0 9 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, dev interface
       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                 :            : #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
      12                 :            : 
      13                 :            : #include <linux/module.h>
      14                 :            : #include <linux/rtc.h>
      15                 :            : #include <linux/sched/signal.h>
      16                 :            : #include "rtc-core.h"
      17                 :            : 
      18                 :            : static dev_t rtc_devt;
      19                 :            : 
      20                 :            : #define RTC_DEV_MAX 16 /* 16 RTCs should be enough for everyone... */
      21                 :            : 
      22                 :          0 : static int rtc_dev_open(struct inode *inode, struct file *file)
      23                 :            : {
      24                 :          0 :         struct rtc_device *rtc = container_of(inode->i_cdev,
      25                 :            :                                         struct rtc_device, char_dev);
      26                 :            : 
      27                 :          0 :         if (test_and_set_bit_lock(RTC_DEV_BUSY, &rtc->flags))
      28                 :            :                 return -EBUSY;
      29                 :            : 
      30                 :          0 :         file->private_data = rtc;
      31                 :            : 
      32                 :            :         spin_lock_irq(&rtc->irq_lock);
      33                 :          0 :         rtc->irq_data = 0;
      34                 :            :         spin_unlock_irq(&rtc->irq_lock);
      35                 :            : 
      36                 :          0 :         return 0;
      37                 :            : }
      38                 :            : 
      39                 :            : #ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
      40                 :            : /*
      41                 :            :  * Routine to poll RTC seconds field for change as often as possible,
      42                 :            :  * after first RTC_UIE use timer to reduce polling
      43                 :            :  */
      44                 :            : static void rtc_uie_task(struct work_struct *work)
      45                 :            : {
      46                 :            :         struct rtc_device *rtc =
      47                 :            :                 container_of(work, struct rtc_device, uie_task);
      48                 :            :         struct rtc_time tm;
      49                 :            :         int num = 0;
      50                 :            :         int err;
      51                 :            : 
      52                 :            :         err = rtc_read_time(rtc, &tm);
      53                 :            : 
      54                 :            :         spin_lock_irq(&rtc->irq_lock);
      55                 :            :         if (rtc->stop_uie_polling || err) {
      56                 :            :                 rtc->uie_task_active = 0;
      57                 :            :         } else if (rtc->oldsecs != tm.tm_sec) {
      58                 :            :                 num = (tm.tm_sec + 60 - rtc->oldsecs) % 60;
      59                 :            :                 rtc->oldsecs = tm.tm_sec;
      60                 :            :                 rtc->uie_timer.expires = jiffies + HZ - (HZ / 10);
      61                 :            :                 rtc->uie_timer_active = 1;
      62                 :            :                 rtc->uie_task_active = 0;
      63                 :            :                 add_timer(&rtc->uie_timer);
      64                 :            :         } else if (schedule_work(&rtc->uie_task) == 0) {
      65                 :            :                 rtc->uie_task_active = 0;
      66                 :            :         }
      67                 :            :         spin_unlock_irq(&rtc->irq_lock);
      68                 :            :         if (num)
      69                 :            :                 rtc_handle_legacy_irq(rtc, num, RTC_UF);
      70                 :            : }
      71                 :            : 
      72                 :            : static void rtc_uie_timer(struct timer_list *t)
      73                 :            : {
      74                 :            :         struct rtc_device *rtc = from_timer(rtc, t, uie_timer);
      75                 :            :         unsigned long flags;
      76                 :            : 
      77                 :            :         spin_lock_irqsave(&rtc->irq_lock, flags);
      78                 :            :         rtc->uie_timer_active = 0;
      79                 :            :         rtc->uie_task_active = 1;
      80                 :            :         if ((schedule_work(&rtc->uie_task) == 0))
      81                 :            :                 rtc->uie_task_active = 0;
      82                 :            :         spin_unlock_irqrestore(&rtc->irq_lock, flags);
      83                 :            : }
      84                 :            : 
      85                 :            : static int clear_uie(struct rtc_device *rtc)
      86                 :            : {
      87                 :            :         spin_lock_irq(&rtc->irq_lock);
      88                 :            :         if (rtc->uie_irq_active) {
      89                 :            :                 rtc->stop_uie_polling = 1;
      90                 :            :                 if (rtc->uie_timer_active) {
      91                 :            :                         spin_unlock_irq(&rtc->irq_lock);
      92                 :            :                         del_timer_sync(&rtc->uie_timer);
      93                 :            :                         spin_lock_irq(&rtc->irq_lock);
      94                 :            :                         rtc->uie_timer_active = 0;
      95                 :            :                 }
      96                 :            :                 if (rtc->uie_task_active) {
      97                 :            :                         spin_unlock_irq(&rtc->irq_lock);
      98                 :            :                         flush_scheduled_work();
      99                 :            :                         spin_lock_irq(&rtc->irq_lock);
     100                 :            :                 }
     101                 :            :                 rtc->uie_irq_active = 0;
     102                 :            :         }
     103                 :            :         spin_unlock_irq(&rtc->irq_lock);
     104                 :            :         return 0;
     105                 :            : }
     106                 :            : 
     107                 :            : static int set_uie(struct rtc_device *rtc)
     108                 :            : {
     109                 :            :         struct rtc_time tm;
     110                 :            :         int err;
     111                 :            : 
     112                 :            :         err = rtc_read_time(rtc, &tm);
     113                 :            :         if (err)
     114                 :            :                 return err;
     115                 :            :         spin_lock_irq(&rtc->irq_lock);
     116                 :            :         if (!rtc->uie_irq_active) {
     117                 :            :                 rtc->uie_irq_active = 1;
     118                 :            :                 rtc->stop_uie_polling = 0;
     119                 :            :                 rtc->oldsecs = tm.tm_sec;
     120                 :            :                 rtc->uie_task_active = 1;
     121                 :            :                 if (schedule_work(&rtc->uie_task) == 0)
     122                 :            :                         rtc->uie_task_active = 0;
     123                 :            :         }
     124                 :            :         rtc->irq_data = 0;
     125                 :            :         spin_unlock_irq(&rtc->irq_lock);
     126                 :            :         return 0;
     127                 :            : }
     128                 :            : 
     129                 :            : int rtc_dev_update_irq_enable_emul(struct rtc_device *rtc, unsigned int enabled)
     130                 :            : {
     131                 :            :         if (enabled)
     132                 :            :                 return set_uie(rtc);
     133                 :            :         else
     134                 :            :                 return clear_uie(rtc);
     135                 :            : }
     136                 :            : EXPORT_SYMBOL(rtc_dev_update_irq_enable_emul);
     137                 :            : 
     138                 :            : #endif /* CONFIG_RTC_INTF_DEV_UIE_EMUL */
     139                 :            : 
     140                 :            : static ssize_t
     141                 :          0 : rtc_dev_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
     142                 :            : {
     143                 :          0 :         struct rtc_device *rtc = file->private_data;
     144                 :            : 
     145                 :          0 :         DECLARE_WAITQUEUE(wait, current);
     146                 :            :         unsigned long data;
     147                 :            :         ssize_t ret;
     148                 :            : 
     149                 :          0 :         if (count != sizeof(unsigned int) && count < sizeof(unsigned long))
     150                 :            :                 return -EINVAL;
     151                 :            : 
     152                 :          0 :         add_wait_queue(&rtc->irq_queue, &wait);
     153                 :            :         do {
     154                 :          0 :                 __set_current_state(TASK_INTERRUPTIBLE);
     155                 :            : 
     156                 :            :                 spin_lock_irq(&rtc->irq_lock);
     157                 :          0 :                 data = rtc->irq_data;
     158                 :          0 :                 rtc->irq_data = 0;
     159                 :            :                 spin_unlock_irq(&rtc->irq_lock);
     160                 :            : 
     161                 :          0 :                 if (data != 0) {
     162                 :            :                         ret = 0;
     163                 :            :                         break;
     164                 :            :                 }
     165                 :          0 :                 if (file->f_flags & O_NONBLOCK) {
     166                 :            :                         ret = -EAGAIN;
     167                 :            :                         break;
     168                 :            :                 }
     169                 :          0 :                 if (signal_pending(current)) {
     170                 :            :                         ret = -ERESTARTSYS;
     171                 :            :                         break;
     172                 :            :                 }
     173                 :          0 :                 schedule();
     174                 :          0 :         } while (1);
     175                 :          0 :         set_current_state(TASK_RUNNING);
     176                 :          0 :         remove_wait_queue(&rtc->irq_queue, &wait);
     177                 :            : 
     178                 :          0 :         if (ret == 0) {
     179                 :            :                 if (sizeof(int) != sizeof(long) &&
     180                 :            :                     count == sizeof(unsigned int))
     181                 :            :                         ret = put_user(data, (unsigned int __user *)buf) ?:
     182                 :            :                                 sizeof(unsigned int);
     183                 :            :                 else
     184                 :          0 :                         ret = put_user(data, (unsigned long __user *)buf) ?:
     185                 :            :                                 sizeof(unsigned long);
     186                 :            :         }
     187                 :          0 :         return ret;
     188                 :            : }
     189                 :            : 
     190                 :          0 : static __poll_t rtc_dev_poll(struct file *file, poll_table *wait)
     191                 :            : {
     192                 :          0 :         struct rtc_device *rtc = file->private_data;
     193                 :            :         unsigned long data;
     194                 :            : 
     195                 :          0 :         poll_wait(file, &rtc->irq_queue, wait);
     196                 :            : 
     197                 :          0 :         data = rtc->irq_data;
     198                 :            : 
     199                 :          0 :         return (data != 0) ? (EPOLLIN | EPOLLRDNORM) : 0;
     200                 :            : }
     201                 :            : 
     202                 :          0 : static long rtc_dev_ioctl(struct file *file,
     203                 :            :                           unsigned int cmd, unsigned long arg)
     204                 :            : {
     205                 :            :         int err = 0;
     206                 :          0 :         struct rtc_device *rtc = file->private_data;
     207                 :          0 :         const struct rtc_class_ops *ops = rtc->ops;
     208                 :            :         struct rtc_time tm;
     209                 :            :         struct rtc_wkalrm alarm;
     210                 :          0 :         void __user *uarg = (void __user *)arg;
     211                 :            : 
     212                 :          0 :         err = mutex_lock_interruptible(&rtc->ops_lock);
     213                 :          0 :         if (err)
     214                 :            :                 return err;
     215                 :            : 
     216                 :            :         /* check that the calling task has appropriate permissions
     217                 :            :          * for certain ioctls. doing this check here is useful
     218                 :            :          * to avoid duplicate code in each driver.
     219                 :            :          */
     220                 :          0 :         switch (cmd) {
     221                 :            :         case RTC_EPOCH_SET:
     222                 :            :         case RTC_SET_TIME:
     223                 :          0 :                 if (!capable(CAP_SYS_TIME))
     224                 :            :                         err = -EACCES;
     225                 :            :                 break;
     226                 :            : 
     227                 :            :         case RTC_IRQP_SET:
     228                 :          0 :                 if (arg > rtc->max_user_freq && !capable(CAP_SYS_RESOURCE))
     229                 :            :                         err = -EACCES;
     230                 :            :                 break;
     231                 :            : 
     232                 :            :         case RTC_PIE_ON:
     233                 :          0 :                 if (rtc->irq_freq > rtc->max_user_freq &&
     234                 :          0 :                     !capable(CAP_SYS_RESOURCE))
     235                 :            :                         err = -EACCES;
     236                 :            :                 break;
     237                 :            :         }
     238                 :            : 
     239                 :          0 :         if (err)
     240                 :            :                 goto done;
     241                 :            : 
     242                 :            :         /*
     243                 :            :          * Drivers *SHOULD NOT* provide ioctl implementations
     244                 :            :          * for these requests.  Instead, provide methods to
     245                 :            :          * support the following code, so that the RTC's main
     246                 :            :          * features are accessible without using ioctls.
     247                 :            :          *
     248                 :            :          * RTC and alarm times will be in UTC, by preference,
     249                 :            :          * but dual-booting with MS-Windows implies RTCs must
     250                 :            :          * use the local wall clock time.
     251                 :            :          */
     252                 :            : 
     253                 :          0 :         switch (cmd) {
     254                 :            :         case RTC_ALM_READ:
     255                 :          0 :                 mutex_unlock(&rtc->ops_lock);
     256                 :            : 
     257                 :          0 :                 err = rtc_read_alarm(rtc, &alarm);
     258                 :          0 :                 if (err < 0)
     259                 :            :                         return err;
     260                 :            : 
     261                 :          0 :                 if (copy_to_user(uarg, &alarm.time, sizeof(tm)))
     262                 :            :                         err = -EFAULT;
     263                 :          0 :                 return err;
     264                 :            : 
     265                 :            :         case RTC_ALM_SET:
     266                 :          0 :                 mutex_unlock(&rtc->ops_lock);
     267                 :            : 
     268                 :          0 :                 if (copy_from_user(&alarm.time, uarg, sizeof(tm)))
     269                 :            :                         return -EFAULT;
     270                 :            : 
     271                 :          0 :                 alarm.enabled = 0;
     272                 :          0 :                 alarm.pending = 0;
     273                 :          0 :                 alarm.time.tm_wday = -1;
     274                 :          0 :                 alarm.time.tm_yday = -1;
     275                 :          0 :                 alarm.time.tm_isdst = -1;
     276                 :            : 
     277                 :            :                 /* RTC_ALM_SET alarms may be up to 24 hours in the future.
     278                 :            :                  * Rather than expecting every RTC to implement "don't care"
     279                 :            :                  * for day/month/year fields, just force the alarm to have
     280                 :            :                  * the right values for those fields.
     281                 :            :                  *
     282                 :            :                  * RTC_WKALM_SET should be used instead.  Not only does it
     283                 :            :                  * eliminate the need for a separate RTC_AIE_ON call, it
     284                 :            :                  * doesn't have the "alarm 23:59:59 in the future" race.
     285                 :            :                  *
     286                 :            :                  * NOTE:  some legacy code may have used invalid fields as
     287                 :            :                  * wildcards, exposing hardware "periodic alarm" capabilities.
     288                 :            :                  * Not supported here.
     289                 :            :                  */
     290                 :            :                 {
     291                 :            :                         time64_t now, then;
     292                 :            : 
     293                 :          0 :                         err = rtc_read_time(rtc, &tm);
     294                 :          0 :                         if (err < 0)
     295                 :            :                                 return err;
     296                 :          0 :                         now = rtc_tm_to_time64(&tm);
     297                 :            : 
     298                 :          0 :                         alarm.time.tm_mday = tm.tm_mday;
     299                 :          0 :                         alarm.time.tm_mon = tm.tm_mon;
     300                 :          0 :                         alarm.time.tm_year = tm.tm_year;
     301                 :          0 :                         err  = rtc_valid_tm(&alarm.time);
     302                 :          0 :                         if (err < 0)
     303                 :            :                                 return err;
     304                 :          0 :                         then = rtc_tm_to_time64(&alarm.time);
     305                 :            : 
     306                 :            :                         /* alarm may need to wrap into tomorrow */
     307                 :          0 :                         if (then < now) {
     308                 :          0 :                                 rtc_time64_to_tm(now + 24 * 60 * 60, &tm);
     309                 :          0 :                                 alarm.time.tm_mday = tm.tm_mday;
     310                 :          0 :                                 alarm.time.tm_mon = tm.tm_mon;
     311                 :          0 :                                 alarm.time.tm_year = tm.tm_year;
     312                 :            :                         }
     313                 :            :                 }
     314                 :            : 
     315                 :          0 :                 return rtc_set_alarm(rtc, &alarm);
     316                 :            : 
     317                 :            :         case RTC_RD_TIME:
     318                 :          0 :                 mutex_unlock(&rtc->ops_lock);
     319                 :            : 
     320                 :          0 :                 err = rtc_read_time(rtc, &tm);
     321                 :          0 :                 if (err < 0)
     322                 :            :                         return err;
     323                 :            : 
     324                 :          0 :                 if (copy_to_user(uarg, &tm, sizeof(tm)))
     325                 :            :                         err = -EFAULT;
     326                 :          0 :                 return err;
     327                 :            : 
     328                 :            :         case RTC_SET_TIME:
     329                 :          0 :                 mutex_unlock(&rtc->ops_lock);
     330                 :            : 
     331                 :          0 :                 if (copy_from_user(&tm, uarg, sizeof(tm)))
     332                 :            :                         return -EFAULT;
     333                 :            : 
     334                 :          0 :                 return rtc_set_time(rtc, &tm);
     335                 :            : 
     336                 :            :         case RTC_PIE_ON:
     337                 :          0 :                 err = rtc_irq_set_state(rtc, 1);
     338                 :          0 :                 break;
     339                 :            : 
     340                 :            :         case RTC_PIE_OFF:
     341                 :          0 :                 err = rtc_irq_set_state(rtc, 0);
     342                 :          0 :                 break;
     343                 :            : 
     344                 :            :         case RTC_AIE_ON:
     345                 :          0 :                 mutex_unlock(&rtc->ops_lock);
     346                 :          0 :                 return rtc_alarm_irq_enable(rtc, 1);
     347                 :            : 
     348                 :            :         case RTC_AIE_OFF:
     349                 :          0 :                 mutex_unlock(&rtc->ops_lock);
     350                 :          0 :                 return rtc_alarm_irq_enable(rtc, 0);
     351                 :            : 
     352                 :            :         case RTC_UIE_ON:
     353                 :          0 :                 mutex_unlock(&rtc->ops_lock);
     354                 :          0 :                 return rtc_update_irq_enable(rtc, 1);
     355                 :            : 
     356                 :            :         case RTC_UIE_OFF:
     357                 :          0 :                 mutex_unlock(&rtc->ops_lock);
     358                 :          0 :                 return rtc_update_irq_enable(rtc, 0);
     359                 :            : 
     360                 :            :         case RTC_IRQP_SET:
     361                 :          0 :                 err = rtc_irq_set_freq(rtc, arg);
     362                 :          0 :                 break;
     363                 :            : 
     364                 :            :         case RTC_IRQP_READ:
     365                 :          0 :                 err = put_user(rtc->irq_freq, (unsigned long __user *)uarg);
     366                 :          0 :                 break;
     367                 :            : 
     368                 :            :         case RTC_WKALM_SET:
     369                 :          0 :                 mutex_unlock(&rtc->ops_lock);
     370                 :          0 :                 if (copy_from_user(&alarm, uarg, sizeof(alarm)))
     371                 :            :                         return -EFAULT;
     372                 :            : 
     373                 :          0 :                 return rtc_set_alarm(rtc, &alarm);
     374                 :            : 
     375                 :            :         case RTC_WKALM_RD:
     376                 :          0 :                 mutex_unlock(&rtc->ops_lock);
     377                 :          0 :                 err = rtc_read_alarm(rtc, &alarm);
     378                 :          0 :                 if (err < 0)
     379                 :            :                         return err;
     380                 :            : 
     381                 :          0 :                 if (copy_to_user(uarg, &alarm, sizeof(alarm)))
     382                 :            :                         err = -EFAULT;
     383                 :          0 :                 return err;
     384                 :            : 
     385                 :            :         default:
     386                 :            :                 /* Finally try the driver's ioctl interface */
     387                 :          0 :                 if (ops->ioctl) {
     388                 :          0 :                         err = ops->ioctl(rtc->dev.parent, cmd, arg);
     389                 :          0 :                         if (err == -ENOIOCTLCMD)
     390                 :            :                                 err = -ENOTTY;
     391                 :            :                 } else {
     392                 :            :                         err = -ENOTTY;
     393                 :            :                 }
     394                 :            :                 break;
     395                 :            :         }
     396                 :            : 
     397                 :            : done:
     398                 :          0 :         mutex_unlock(&rtc->ops_lock);
     399                 :          0 :         return err;
     400                 :            : }
     401                 :            : 
     402                 :          0 : static int rtc_dev_fasync(int fd, struct file *file, int on)
     403                 :            : {
     404                 :          0 :         struct rtc_device *rtc = file->private_data;
     405                 :            : 
     406                 :          0 :         return fasync_helper(fd, file, on, &rtc->async_queue);
     407                 :            : }
     408                 :            : 
     409                 :          0 : static int rtc_dev_release(struct inode *inode, struct file *file)
     410                 :            : {
     411                 :          0 :         struct rtc_device *rtc = file->private_data;
     412                 :            : 
     413                 :            :         /* We shut down the repeating IRQs that userspace enabled,
     414                 :            :          * since nothing is listening to them.
     415                 :            :          *  - Update (UIE) ... currently only managed through ioctls
     416                 :            :          *  - Periodic (PIE) ... also used through rtc_*() interface calls
     417                 :            :          *
     418                 :            :          * Leave the alarm alone; it may be set to trigger a system wakeup
     419                 :            :          * later, or be used by kernel code, and is a one-shot event anyway.
     420                 :            :          */
     421                 :            : 
     422                 :            :         /* Keep ioctl until all drivers are converted */
     423                 :          0 :         rtc_dev_ioctl(file, RTC_UIE_OFF, 0);
     424                 :          0 :         rtc_update_irq_enable(rtc, 0);
     425                 :          0 :         rtc_irq_set_state(rtc, 0);
     426                 :            : 
     427                 :          0 :         clear_bit_unlock(RTC_DEV_BUSY, &rtc->flags);
     428                 :          0 :         return 0;
     429                 :            : }
     430                 :            : 
     431                 :            : static const struct file_operations rtc_dev_fops = {
     432                 :            :         .owner          = THIS_MODULE,
     433                 :            :         .llseek         = no_llseek,
     434                 :            :         .read           = rtc_dev_read,
     435                 :            :         .poll           = rtc_dev_poll,
     436                 :            :         .unlocked_ioctl = rtc_dev_ioctl,
     437                 :            :         .open           = rtc_dev_open,
     438                 :            :         .release        = rtc_dev_release,
     439                 :            :         .fasync         = rtc_dev_fasync,
     440                 :            : };
     441                 :            : 
     442                 :            : /* insertion/removal hooks */
     443                 :            : 
     444                 :          0 : void rtc_dev_prepare(struct rtc_device *rtc)
     445                 :            : {
     446                 :          0 :         if (!rtc_devt)
     447                 :            :                 return;
     448                 :            : 
     449                 :          0 :         if (rtc->id >= RTC_DEV_MAX) {
     450                 :            :                 dev_dbg(&rtc->dev, "too many RTC devices\n");
     451                 :            :                 return;
     452                 :            :         }
     453                 :            : 
     454                 :          0 :         rtc->dev.devt = MKDEV(MAJOR(rtc_devt), rtc->id);
     455                 :            : 
     456                 :            : #ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
     457                 :            :         INIT_WORK(&rtc->uie_task, rtc_uie_task);
     458                 :            :         timer_setup(&rtc->uie_timer, rtc_uie_timer, 0);
     459                 :            : #endif
     460                 :            : 
     461                 :          0 :         cdev_init(&rtc->char_dev, &rtc_dev_fops);
     462                 :          0 :         rtc->char_dev.owner = rtc->owner;
     463                 :            : }
     464                 :            : 
     465                 :          3 : void __init rtc_dev_init(void)
     466                 :            : {
     467                 :            :         int err;
     468                 :            : 
     469                 :          3 :         err = alloc_chrdev_region(&rtc_devt, 0, RTC_DEV_MAX, "rtc");
     470                 :          3 :         if (err < 0)
     471                 :          0 :                 pr_err("failed to allocate char dev region\n");
     472                 :          3 : }
     473                 :            : 
     474                 :          0 : void __exit rtc_dev_exit(void)
     475                 :            : {
     476                 :          0 :         if (rtc_devt)
     477                 :          0 :                 unregister_chrdev_region(rtc_devt, RTC_DEV_MAX);
     478                 :          0 : }
    

Generated by: LCOV version 1.14