/* *	Real Time Clock interface for Linux	 * *	Copyright (C) 1996 Paul Gortmaker * *	This driver allows use of the real time clock (built into *	nearly all computers) from user space. It exports the /dev/rtc *	interface supporting various ioctl() and also the /proc/rtc *	pseudo-file for status information. * *	The ioctls can be used to set the interrupt behaviour and *	generation rate from the RTC via IRQ 8. Then the /dev/rtc *	interface can be used to make use of these timer interrupts, *	be they interval or alarm based. * *	The /dev/rtc interface will block on reads until an interrupt *	has been received. If a RTC interrupt has already happened, *	it will output an unsigned long and then block. The output value *	contains the interrupt status in the low byte and the number of *	interrupts since the last read in the remaining high bytes. The  *	/dev/rtc interface can also be used with the select(2) call. * *	This program is free software; you can redistribute it and/or *	modify it under the terms of the GNU General Public License *	as published by the Free Software Foundation; either version *	2 of the License, or (at your option) any later version. * *	Based on other minimal char device drivers, like Alan's *	watchdog, Ted's random, etc. etc. * *	1.07	Paul Gortmaker. *	1.08	Miquel van Smoorenburg: disallow certain things on the *		DEC Alpha as the CMOS clock is also used for other things. *	1.09	Nikita Schmidt: epoch support and some Alpha cleanup. * */#define RTC_VERSION		"1.09"#define RTC_IRQ 	8	/* Can't see this changing soon.	*/#define RTC_IO_EXTENT	0x10	/* Only really two ports, but...	*//* *	Note that *all* calls to CMOS_READ and CMOS_WRITE are done with *	interrupts disabled. Due to the index-port/data-port (0x70/0x71) *	design of the RTC, we don't want two different things trying to *	get to it at once. (e.g. the periodic 11 min sync from time.c vs. *	this driver.) */#include <linux/types.h>#include <linux/errno.h>#include <linux/miscdevice.h>#include <linux/malloc.h>#include <linux/ioport.h>#include <linux/fcntl.h>#include <linux/mc146818rtc.h>#include <linux/init.h>#include <linux/poll.h>#include <asm/io.h>#include <asm/uaccess.h>#include <asm/system.h>/* *	We sponge a minor off of the misc major. No need slurping *	up another valuable major dev number for this. If you add *	an ioctl, make sure you don't conflict with SPARC's RTC *	ioctls. */static struct wait_queue *rtc_wait;static struct timer_list rtc_irq_timer;static long long rtc_llseek(struct file *file, loff_t offset, int origin);static ssize_t rtc_read(struct file *file, char *buf,			size_t count, loff_t *ppos);static int rtc_ioctl(struct inode *inode, struct file *file,		     unsigned int cmd, unsigned long arg);static unsigned int rtc_poll(struct file *file, poll_table *wait);void get_rtc_time (struct rtc_time *rtc_tm);void get_rtc_alm_time (struct rtc_time *alm_tm);void rtc_dropped_irq(unsigned long data);void set_rtc_irq_bit(unsigned char bit);void mask_rtc_irq_bit(unsigned char bit);static inline unsigned char rtc_is_updating(void);/* *	Bits in rtc_status. (6 bits of room for future expansion) */#define RTC_IS_OPEN		0x01	/* means /dev/rtc is in use	*/#define RTC_TIMER_ON		0x02	/* missed irq timer active	*/unsigned char rtc_status = 0;		/* bitmapped status byte.	*/unsigned long rtc_freq = 0;		/* Current periodic IRQ rate	*/unsigned long rtc_irq_data = 0;		/* our output to the world	*//* *	If this driver ever becomes modularised, it will be really nice *	to make the epoch retain its value across module reload... */static unsigned long epoch = 1900;	/* year corresponding to 0x00	*/unsigned char days_in_mo[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};/* *	A very tiny interrupt handler. It runs with SA_INTERRUPT set, *	so that there is no possibility of conflicting with the *	set_rtc_mmss() call that happens during some timer interrupts. *	(See ./arch/XXXX/kernel/time.c for the set_rtc_mmss() function.) */static void rtc_interrupt(int irq, void *dev_id, struct pt_regs *regs){	/*	 *	Can be an alarm interrupt, update complete interrupt,	 *	or a periodic interrupt. We store the status in the	 *	low byte and the number of interrupts received since	 *	the last read in the remainder of rtc_irq_data.	 */	rtc_irq_data += 0x100;	rtc_irq_data &= ~0xff;	rtc_irq_data |= (CMOS_READ(RTC_INTR_FLAGS) & 0xF0);	wake_up_interruptible(&rtc_wait);		if (rtc_status & RTC_TIMER_ON)		mod_timer(&rtc_irq_timer, jiffies + HZ/rtc_freq + 2*HZ/100);}/* *	Now all the various file operations that we export. */static long long rtc_llseek(struct file *file, loff_t offset, int origin){	return -ESPIPE;}static ssize_t rtc_read(struct file *file, char *buf,			size_t count, loff_t *ppos){	struct wait_queue wait = { current, NULL };	unsigned long data;	ssize_t retval;		if (count < sizeof(unsigned long))		return -EINVAL;	add_wait_queue(&rtc_wait, &wait);	current->state = TASK_INTERRUPTIBLE;			while ((data = xchg(&rtc_irq_data, 0)) == 0) {		if (file->f_flags & O_NONBLOCK) {			retval = -EAGAIN;			goto out;		}		if (signal_pending(current)) {			retval = -ERESTARTSYS;			goto out;		}		schedule();	}	retval = put_user(data, (unsigned long *)buf); 	if (!retval)		retval = sizeof(unsigned long);  out:	current->state = TASK_RUNNING;	remove_wait_queue(&rtc_wait, &wait);	return retval;}static int rtc_ioctl(struct inode *inode, struct file *file, unsigned int cmd,		     unsigned long arg){	unsigned long flags;	struct rtc_time wtime; 	switch (cmd) {	case RTC_AIE_OFF:	/* Mask alarm int. enab. bit	*/	{		mask_rtc_irq_bit(RTC_AIE);		return 0;	}	case RTC_AIE_ON:	/* Allow alarm interrupts.	*/	{		set_rtc_irq_bit(RTC_AIE);		return 0;	}	case RTC_PIE_OFF:	/* Mask periodic int. enab. bit	*/	{		mask_rtc_irq_bit(RTC_PIE);		if (rtc_status & RTC_TIMER_ON) {			del_timer(&rtc_irq_timer);			rtc_status &= ~RTC_TIMER_ON;		}		return 0;	}	case RTC_PIE_ON:	/* Allow periodic ints		*/	{		/*		 * We don't really want Joe User enabling more		 * than 64Hz of interrupts on a multi-user machine.		 */		if ((rtc_freq > 64) && (!capable(CAP_SYS_RESOURCE)))			return -EACCES;		if (!(rtc_status & RTC_TIMER_ON)) {			rtc_status |= RTC_TIMER_ON;			rtc_irq_timer.expires = jiffies + HZ/rtc_freq + 2*HZ/100;			add_timer(&rtc_irq_timer);		}		set_rtc_irq_bit(RTC_PIE);		return 0;	}	case RTC_UIE_OFF:	/* Mask ints from RTC updates.	*/	{		mask_rtc_irq_bit(RTC_UIE);		return 0;	}	case RTC_UIE_ON:	/* Allow ints for RTC updates.	*/	{		set_rtc_irq_bit(RTC_UIE);		return 0;	}	case RTC_ALM_READ:	/* Read the present alarm time */	{		/*		 * This returns a struct rtc_time. Reading >= 0xc0		 * means "don't care" or "match all". Only the tm_hour,		 * tm_min, and tm_sec values are filled in.		 */		get_rtc_alm_time(&wtime);		break; 	}	case RTC_ALM_SET:	/* Store a time into the alarm */	{		/*		 * This expects a struct rtc_time. Writing 0xff means		 * "don't care" or "match all". Only the tm_hour,		 * tm_min and tm_sec are used.		 */		unsigned char hrs, min, sec;		struct rtc_time alm_tm;		if (copy_from_user(&alm_tm, (struct rtc_time*)arg,				   sizeof(struct rtc_time)))			return -EFAULT;		hrs = alm_tm.tm_hour;		min = alm_tm.tm_min;		sec = alm_tm.tm_sec;		if (hrs >= 24)			hrs = 0xff;		if (min >= 60)			min = 0xff;		if (sec >= 60)			sec = 0xff;		save_flags(flags);		cli();		if (!(CMOS_READ(RTC_CONTROL) & RTC_DM_BINARY) ||		    RTC_ALWAYS_BCD)		{			BIN_TO_BCD(sec);			BIN_TO_BCD(min);			BIN_TO_BCD(hrs);		}		CMOS_WRITE(hrs, RTC_HOURS_ALARM);		CMOS_WRITE(min, RTC_MINUTES_ALARM);		CMOS_WRITE(sec, RTC_SECONDS_ALARM);		restore_flags(flags);		return 0;	}	case RTC_RD_TIME:	/* Read the time/date from RTC	*/	{		get_rtc_time(&wtime);		break;	}	case RTC_SET_TIME:	/* Set the RTC */	{		struct rtc_time rtc_tm;		unsigned char mon, day, hrs, min, sec, leap_yr;		unsigned char save_control, save_freq_select;		unsigned int yrs;		unsigned long flags;					if (!capable(CAP_SYS_TIME))			return -EACCES;		if (copy_from_user(&rtc_tm, (struct rtc_time*)arg,				   sizeof(struct rtc_time)))			return -EFAULT;		yrs = rtc_tm.tm_year + 1900;		mon = rtc_tm.tm_mon + 1;   /* tm_mon starts at zero */		day = rtc_tm.tm_mday;		hrs = rtc_tm.tm_hour;		min = rtc_tm.tm_min;		sec = rtc_tm.tm_sec;		if (yrs < 1970)			return -EINVAL;		leap_yr = ((!(yrs % 4) && (yrs % 100)) || !(yrs % 400));		if ((mon > 12) || (day == 0))			return -EINVAL;		if (day > (days_in_mo[mon] + ((mon == 2) && leap_yr)))			return -EINVAL;					if ((hrs >= 24) || (min >= 60) || (sec >= 60))			return -EINVAL;		if ((yrs -= epoch) > 255)    /* They are unsigned */			return -EINVAL;		save_flags(flags);		cli();		if (!(CMOS_READ(RTC_CONTROL) & RTC_DM_BINARY)		    || RTC_ALWAYS_BCD) {			if (yrs > 169) {				restore_flags(flags);				return -EINVAL;			}			if (yrs >= 100)				yrs -= 100;			BIN_TO_BCD(sec);			BIN_TO_BCD(min);			BIN_TO_BCD(hrs);			BIN_TO_BCD(day);			BIN_TO_BCD(mon);			BIN_TO_BCD(yrs);		}		save_control = CMOS_READ(RTC_CONTROL);		CMOS_WRITE((save_control|RTC_SET), RTC_CONTROL);		save_freq_select = CMOS_READ(RTC_FREQ_SELECT);		CMOS_WRITE((save_freq_select|RTC_DIV_RESET2), RTC_FREQ_SELECT);		CMOS_WRITE(yrs, RTC_YEAR);		CMOS_WRITE(mon, RTC_MONTH);		CMOS_WRITE(day, RTC_DAY_OF_MONTH);		CMOS_WRITE(hrs, RTC_HOURS);		CMOS_WRITE(min, RTC_MINUTES);		CMOS_WRITE(sec, RTC_SECONDS);		CMOS_WRITE(save_control, RTC_CONTROL);		CMOS_WRITE(save_freq_select, RTC_FREQ_SELECT);		restore_flags(flags);		return 0;	}	case RTC_IRQP_READ:	/* Read the periodic IRQ rate.	*/	{		return put_user(rtc_freq, (unsigned long *)arg);	}	case RTC_IRQP_SET:	/* Set periodic IRQ rate.	*/	{		int tmp = 0;		unsigned char val;		/* 		 * The max we can do is 8192Hz.		 */		if ((arg < 2) || (arg > 8192))			return -EINVAL;		/*		 * We don't really want Joe User generating more		 * than 64Hz of interrupts on a multi-user machine.		 */		if ((arg > 64) && (!capable(CAP_SYS_RESOURCE)))			return -EACCES;		while (arg > (1<<tmp))			tmp++;		/*		 * Check that the input was really a power of 2.		 */		if (arg != (1<<tmp))			return -EINVAL;		rtc_freq = arg;		save_flags(flags);		cli();		val = CMOS_READ(RTC_FREQ_SELECT) & 0xf0;		val |= (16 - tmp);