/* * linux/drivers/char/ds1742.c * * Dallas DS1742 Real Time Clock driver * * Copyright (C) 2003 TimeSys Corp. * S. James Hill (James.Hill@timesys.com) * (sjhill@realitydiluted.com) * * Copyright (C) 2001 MontaVista Software Inc. * ahennessy@mvista.com * * Copyright (C) 2000-2001 Toshiba Corporation * * 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. * * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 675 Mass Ave, Cambridge, MA 02139, USA. */ #include #include #include #include #include #include #include #include #include #include #include #include #define DS1742_VERSION "2.0" /* * Registers */ #define RTC_CONTROL (rtc_base + 0x7f8) #define RTC_CENTURY (rtc_base + 0x7f8) #define RTC_SECONDS (rtc_base + 0x7f9) #define RTC_MINUTES (rtc_base + 0x7fa) #define RTC_HOURS (rtc_base + 0x7fb) #define RTC_DAY (rtc_base + 0x7fc) #define RTC_DATE (rtc_base + 0x7fd) #define RTC_MONTH (rtc_base + 0x7fe) #define RTC_YEAR (rtc_base + 0x7ff) #define RTC_CENTURY_MASK 0x3f #define RTC_SECONDS_MASK 0x7f #define RTC_DAY_MASK 0x07 /* * Bits in the Control/Century register */ #define RTC_WRITE 0x80 #define RTC_READ 0x40 /* * Bits in the Seconds register */ #define RTC_STOP 0x80 /* * Bits in the Day register */ #define RTC_BATT_FLAG 0x80 #define RTC_FREQ_TEST 0x40 /* * Conversion between binary and BCD */ #define BCD_TO_BIN(val) (((val)&15) + ((val)>>4)*10) #define BIN_TO_BCD(val) ((((val)/10)<<4) + (val)%10) /* * CMOS Year Epoch */ #define EPOCH 2000 /* * The entry /dev/rtc is being used */ #define RTC_IS_OPEN 0x1 static unsigned long rtc_base = 0; static unsigned long rtc_status = 0; static spinlock_t rtc_lock; extern void to_tm(unsigned long tim, struct rtc_time * tm); static unsigned long rtc_ds1742_get_time(void) { unsigned int year, month, day, hour, minute, second; unsigned int century; CMOS_WRITE(RTC_READ, RTC_CONTROL); second = BCD_TO_BIN(CMOS_READ(RTC_SECONDS) & RTC_SECONDS_MASK); minute = BCD_TO_BIN(CMOS_READ(RTC_MINUTES)); hour = BCD_TO_BIN(CMOS_READ(RTC_HOURS)); day = BCD_TO_BIN(CMOS_READ(RTC_DATE)); month = BCD_TO_BIN(CMOS_READ(RTC_MONTH)); year = BCD_TO_BIN(CMOS_READ(RTC_YEAR)); century = BCD_TO_BIN(CMOS_READ(RTC_CENTURY) & RTC_CENTURY_MASK); CMOS_WRITE(0, RTC_CONTROL); year += century * 100; return mktime(year, month, day, hour, minute, second); } static int rtc_ds1742_set_time(unsigned long t) { struct rtc_time tm; u8 year, month, day, hour, minute, second; u8 cmos_year, cmos_month, cmos_day, cmos_hour, cmos_minute, cmos_second; int cmos_century; CMOS_WRITE(RTC_READ, RTC_CONTROL); cmos_second = (u8)(CMOS_READ(RTC_SECONDS) & RTC_SECONDS_MASK); cmos_minute = (u8)CMOS_READ(RTC_MINUTES); cmos_hour = (u8)CMOS_READ(RTC_HOURS); cmos_day = (u8)CMOS_READ(RTC_DATE); cmos_month = (u8)CMOS_READ(RTC_MONTH); cmos_year = (u8)CMOS_READ(RTC_YEAR); cmos_century = CMOS_READ(RTC_CENTURY) & RTC_CENTURY_MASK; CMOS_WRITE(RTC_WRITE, RTC_CONTROL); /* convert */ to_tm(t, &tm); /* check each field one by one */ year = BIN_TO_BCD(tm.tm_year - EPOCH); if (year != cmos_year) { CMOS_WRITE(year,RTC_YEAR); } month = BIN_TO_BCD(tm.tm_mon + 1); if (month != (cmos_month & 0x1f)) { CMOS_WRITE((month & 0x1f) | (cmos_month & ~0x1f),RTC_MONTH); } day = BIN_TO_BCD(tm.tm_mday); if (day != cmos_day) CMOS_WRITE(day, RTC_DATE); if (cmos_hour & 0x40) { /* 12 hour format */ hour = 0x40; if (tm.tm_hour > 12) { hour |= 0x20 | (BIN_TO_BCD(hour-12) & 0x1f); } else { hour |= BIN_TO_BCD(tm.tm_hour); } } else { /* 24 hour format */ hour = BIN_TO_BCD(tm.tm_hour) & 0x3f; } if (hour != cmos_hour) CMOS_WRITE(hour, RTC_HOURS); minute = BIN_TO_BCD(tm.tm_min); if (minute != cmos_minute) { CMOS_WRITE(minute, RTC_MINUTES); } second = BIN_TO_BCD(tm.tm_sec); if (second != cmos_second) { CMOS_WRITE(second & RTC_SECONDS_MASK,RTC_SECONDS); } /* RTC_CENTURY and RTC_CONTROL share same address... */ CMOS_WRITE(cmos_century, RTC_CONTROL); return 0; } void __init rtc_ds1742_init(unsigned long base) { u8 cmos_second; /* remember the base */ rtc_base = base; db_assert((rtc_base & 0xe0000000) == KSEG1); /* set the function pointers */ rtc_get_time = rtc_ds1742_get_time; rtc_set_time = rtc_ds1742_set_time; /* clear oscillator stop bit */ CMOS_WRITE(RTC_READ, RTC_CONTROL); cmos_second = (u8)(CMOS_READ(RTC_SECONDS) & RTC_SECONDS_MASK); CMOS_WRITE(RTC_WRITE, RTC_CONTROL); CMOS_WRITE(cmos_second, RTC_SECONDS); /* clear msb */ CMOS_WRITE(0, RTC_CONTROL); } static int get_ds1742_status(char *buf) { char *p; struct rtc_time tm; unsigned long curr_time; curr_time = rtc_ds1742_get_time(); to_tm(curr_time, &tm); p = buf; /* * There is no way to tell if the luser has the RTC set for local * time or for Universal Standard Time (GMT). Probably local though. */ p += sprintf(p, "rtc_time\t: %02d:%02d:%02d\n" "rtc_date\t: %04d-%02d-%02d\n" "rtc_epoch\t: %04lu\n", tm.tm_hour, tm.tm_min, tm.tm_sec, tm.tm_year, tm.tm_mon + 1, tm.tm_mday, 0L); return p - buf; } static int ds1742_read_proc(char *page, char **start, off_t off, int count, int *eof, void *data) { int len = get_ds1742_status(page); if (len <= off + count) *eof = 1; *start = page + off; len -= off; if (len > count) len = count; if (len < 0) len = 0; return len; } void rtc_ds1742_wait(void) { while (CMOS_READ(RTC_SECONDS) & 1); while (!(CMOS_READ(RTC_SECONDS) & 1)); } static int ds1742_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) { struct rtc_time rtc_tm; ulong curr_time; switch (cmd) { case RTC_RD_TIME: /* Read the time/date from RTC */ curr_time = rtc_ds1742_get_time(); to_tm(curr_time, &rtc_tm); rtc_tm.tm_year -= 1900; return copy_to_user((void *) arg, &rtc_tm, sizeof(rtc_tm)) ? -EFAULT : 0; case RTC_SET_TIME: /* Set the RTC */ if (!capable(CAP_SYS_TIME)) return -EACCES; if (copy_from_user(&rtc_tm, (struct rtc_time *) arg, sizeof(struct rtc_time))) return -EFAULT; curr_time = mktime(rtc_tm.tm_year + 1900, rtc_tm.tm_mon + 1, /* tm_mon starts from 0 */ rtc_tm.tm_mday, rtc_tm.tm_hour, rtc_tm.tm_min, rtc_tm.tm_sec); return rtc_ds1742_set_time(curr_time); default: return -EINVAL; } } static int ds1742_open(struct inode *inode, struct file *file) { spin_lock_irq(&rtc_lock); if (rtc_status & RTC_IS_OPEN) { spin_unlock_irq(&rtc_lock); return -EBUSY; } rtc_status |= RTC_IS_OPEN; spin_unlock_irq(&rtc_lock); return 0; } static int ds1742_release(struct inode *inode, struct file *file) { spin_lock_irq(&rtc_lock); rtc_status &= ~RTC_IS_OPEN; spin_unlock_irq(&rtc_lock); return 0; } static struct file_operations ds1742_fops = { owner:THIS_MODULE, llseek:no_llseek, ioctl:ds1742_ioctl, open:ds1742_open, release:ds1742_release, }; static struct miscdevice ds1742_dev = { RTC_MINOR, "rtc", &ds1742_fops }; static int __init ds1742_init(void) { printk(KERN_INFO "DS1742 Real Time Clock Driver v%s\n", DS1742_VERSION); misc_register(&ds1742_dev); create_proc_read_entry("driver/rtc", 0, 0, ds1742_read_proc, NULL); return 0; } static void __exit ds1742_exit(void) { remove_proc_entry("driver/rtc", NULL); misc_deregister(&ds1742_dev); } module_init(ds1742_init); module_exit(ds1742_exit); EXPORT_NO_SYMBOLS; MODULE_AUTHOR("Steven J. Hill"); MODULE_LICENSE("GPL");