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 (4191B)

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