cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

rtc.c (3825B)

      1// SPDX-License-Identifier: GPL-2.0
      2/*
      3 *	Real Time Clock interface for Linux on the MVME16x
      4 *
      5 * Based on the PC driver by Paul Gortmaker.
      6 */
      7
      8#define RTC_VERSION		"1.00"
      9
     10#include <linux/types.h>
     11#include <linux/errno.h>
     12#include <linux/miscdevice.h>
     13#include <linux/ioport.h>
     14#include <linux/capability.h>
     15#include <linux/fcntl.h>
     16#include <linux/init.h>
     17#include <linux/poll.h>
     18#include <linux/rtc.h>	/* For struct rtc_time and ioctls, etc */
     19#include <linux/bcd.h>
     20#include <asm/mvme16xhw.h>
     21
     22#include <asm/io.h>
     23#include <linux/uaccess.h>
     24#include <asm/setup.h>
     25
     26/*
     27 *	We sponge a minor off of the misc major. No need slurping
     28 *	up another valuable major dev number for this. If you add
     29 *	an ioctl, make sure you don't conflict with SPARC's RTC
     30 *	ioctls.
     31 */
     32
     33static const unsigned char days_in_mo[] =
     34{0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
     35
     36static atomic_t rtc_ready = ATOMIC_INIT(1);
     37
     38static long rtc_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
     39{
     40	volatile MK48T08ptr_t rtc = (MK48T08ptr_t)MVME_RTC_BASE;
     41	unsigned long flags;
     42	struct rtc_time wtime;
     43	void __user *argp = (void __user *)arg;
     44
     45	switch (cmd) {
     46	case RTC_RD_TIME:	/* Read the time/date from RTC	*/
     47	{
     48		local_irq_save(flags);
     49		/* Ensure clock and real-time-mode-register are accessible */
     50		rtc->ctrl = RTC_READ;
     51		memset(&wtime, 0, sizeof(struct rtc_time));
     52		wtime.tm_sec =  bcd2bin(rtc->bcd_sec);
     53		wtime.tm_min =  bcd2bin(rtc->bcd_min);
     54		wtime.tm_hour = bcd2bin(rtc->bcd_hr);
     55		wtime.tm_mday =  bcd2bin(rtc->bcd_dom);
     56		wtime.tm_mon =  bcd2bin(rtc->bcd_mth)-1;
     57		wtime.tm_year = bcd2bin(rtc->bcd_year);
     58		if (wtime.tm_year < 70)
     59			wtime.tm_year += 100;
     60		wtime.tm_wday = bcd2bin(rtc->bcd_dow)-1;
     61		rtc->ctrl = 0;
     62		local_irq_restore(flags);
     63		return copy_to_user(argp, &wtime, sizeof wtime) ?
     64								-EFAULT : 0;
     65	}
     66	case RTC_SET_TIME:	/* Set the RTC */
     67	{
     68		struct rtc_time rtc_tm;
     69		unsigned char mon, day, hrs, min, sec, leap_yr;
     70		unsigned int yrs;
     71
     72		if (!capable(CAP_SYS_ADMIN))
     73			return -EACCES;
     74
     75		if (copy_from_user(&rtc_tm, argp, sizeof(struct rtc_time)))
     76			return -EFAULT;
     77
     78		yrs = rtc_tm.tm_year;
     79		if (yrs < 1900)
     80			yrs += 1900;
     81		mon = rtc_tm.tm_mon + 1;   /* tm_mon starts at zero */
     82		day = rtc_tm.tm_mday;
     83		hrs = rtc_tm.tm_hour;
     84		min = rtc_tm.tm_min;
     85		sec = rtc_tm.tm_sec;
     86
     87		leap_yr = ((!(yrs % 4) && (yrs % 100)) || !(yrs % 400));
     88
     89		if ((mon > 12) || (day == 0))
     90			return -EINVAL;
     91
     92		if (day > (days_in_mo[mon] + ((mon == 2) && leap_yr)))
     93			return -EINVAL;
     94
     95		if ((hrs >= 24) || (min >= 60) || (sec >= 60))
     96			return -EINVAL;
     97
     98		if (yrs >= 2070)
     99			return -EINVAL;
    100
    101		local_irq_save(flags);
    102		rtc->ctrl     = RTC_WRITE;
    103
    104		rtc->bcd_sec  = bin2bcd(sec);
    105		rtc->bcd_min  = bin2bcd(min);
    106		rtc->bcd_hr   = bin2bcd(hrs);
    107		rtc->bcd_dom  = bin2bcd(day);
    108		rtc->bcd_mth  = bin2bcd(mon);
    109		rtc->bcd_year = bin2bcd(yrs%100);
    110
    111		rtc->ctrl     = 0;
    112		local_irq_restore(flags);
    113		return 0;
    114	}
    115	default:
    116		return -EINVAL;
    117	}
    118}
    119
    120/*
    121 * We enforce only one user at a time here with the open/close.
    122 */
    123static int rtc_open(struct inode *inode, struct file *file)
    124{
    125	if( !atomic_dec_and_test(&rtc_ready) )
    126	{
    127		atomic_inc( &rtc_ready );
    128		return -EBUSY;
    129	}
    130	return 0;
    131}
    132
    133static int rtc_release(struct inode *inode, struct file *file)
    134{
    135	atomic_inc( &rtc_ready );
    136	return 0;
    137}
    138
    139/*
    140 *	The various file operations we support.
    141 */
    142
    143static const struct file_operations rtc_fops = {
    144	.unlocked_ioctl	= rtc_ioctl,
    145	.open		= rtc_open,
    146	.release	= rtc_release,
    147	.llseek		= noop_llseek,
    148};
    149
    150static struct miscdevice rtc_dev=
    151{
    152	.minor =	RTC_MINOR,
    153	.name =		"rtc",
    154	.fops =		&rtc_fops
    155};
    156
    157static int __init rtc_MK48T08_init(void)
    158{
    159	if (!MACH_IS_MVME16x)
    160		return -ENODEV;
    161
    162	pr_info("MK48T08 Real Time Clock Driver v%s\n", RTC_VERSION);
    163	return misc_register(&rtc_dev);
    164}
    165device_initcall(rtc_MK48T08_init);