PageRenderTime 47ms CodeModel.GetById 29ms app.highlight 12ms RepoModel.GetById 1ms app.codeStats 0ms

/arch/m68k/bvme6000/rtc.c

https://bitbucket.org/thekraven/iscream_thunderc-2.6.35
C | 174 lines | 129 code | 26 blank | 19 comment | 23 complexity | d549a04f80f3925671508c90631827b6 MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0
  1/*
  2 *	Real Time Clock interface for Linux on the BVME6000
  3 *
  4 * Based on the PC driver by Paul Gortmaker.
  5 */
  6
  7#define RTC_VERSION		"1.00"
  8
  9#include <linux/types.h>
 10#include <linux/errno.h>
 11#include <linux/miscdevice.h>
 12#include <linux/ioport.h>
 13#include <linux/capability.h>
 14#include <linux/fcntl.h>
 15#include <linux/init.h>
 16#include <linux/poll.h>
 17#include <linux/module.h>
 18#include <linux/mc146818rtc.h>	/* For struct rtc_time and ioctls, etc */
 19#include <linux/bcd.h>
 20#include <asm/bvme6000hw.h>
 21
 22#include <asm/io.h>
 23#include <asm/uaccess.h>
 24#include <asm/system.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};
159
160static struct miscdevice rtc_dev = {
161	.minor =	RTC_MINOR,
162	.name =		"rtc",
163	.fops =		&rtc_fops
164};
165
166static int __init rtc_DP8570A_init(void)
167{
168	if (!MACH_IS_BVME6000)
169		return -ENODEV;
170
171	printk(KERN_INFO "DP8570A Real Time Clock Driver v%s\n", RTC_VERSION);
172	return misc_register(&rtc_dev);
173}
174module_init(rtc_DP8570A_init);