| 0,0 → 1,406 |
|---|
| /* |
| * Project: S.Ha.R.K. |
| * |
| * Coordinators: |
| * Giorgio Buttazzo <giorgio@sssup.it> |
| * Paolo Gai <pj@gandalf.sssup.it> |
| * |
| * Authors : |
| * Paolo Gai <pj@gandalf.sssup.it> |
| * Massimiliano Giorgi <massy@gandalf.sssup.it> |
| * Luca Abeni <luca@gandalf.sssup.it> |
| * (see the web pages for full authors list) |
| * |
| * ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
| * |
| * http://www.sssup.it |
| * http://retis.sssup.it |
| * http://shark.sssup.it |
| */ |
| |
| /** |
| ------------ |
| CVS : $Id: rtc.c,v 1.1 2003-03-24 10:54:17 pj Exp $ |
| |
| File: $File$ |
| Revision: $Revision: 1.1 $ |
| Last update: $Date: 2003-03-24 10:54:17 $ |
| ------------ |
| |
| Author: Massimiliano Giorgi |
| |
| A source from Linux 2.2.9 modified to work with S.Ha.R.K. |
| |
| **/ |
| |
| /* |
| * Copyright (C) 2000 Paolo Gai |
| * |
| * 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 program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| * |
| */ |
| |
| /* |
| * 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 <kernel/kern.h> |
| #include <drivers/rtc.h> |
| #include "_rtc.h" |
| /* |
| #define CMOS_READ(addr) ({ \ |
| outb_p((addr),RTC_PORT(0)); \ |
| inb_p(RTC_PORT(1)); \ |
| }) |
| #define CMOS_WRITE(val, addr) ({ \ |
| outb_p((addr),RTC_PORT(0)); \ |
| outb_p((val),RTC_PORT(1)); \ |
| }) |
| */ |
| |
| #define CMOS_READ(addr) ( \ |
| ll_out(RTC_PORT(0),addr), \ |
| ll_in(RTC_PORT(1)) \ |
| ) |
| |
| #define CMOS_WRITE(val, addr) (\ |
| ll_out(RTC_PORT(0),addr), \ |
| ll_out(RTC_PORT(1),val) \ |
| ) |
| |
| /* |
| * 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. |
| */ |
| |
| |
| int get_rtc_time (struct rtc_time *rtc_tm); |
| int set_rtc_time (struct rtc_time *rtc_tm); |
| int get_rtc_alm_time (struct rtc_time *alm_tm); |
| |
| 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}; |
| |
| /* |
| * Returns true if a clock update is in progress |
| */ |
| static inline unsigned char rtc_is_updating(void) |
| { |
| SYS_FLAGS flags; |
| unsigned char uip; |
| |
| flags=kern_fsave(); |
| uip = (CMOS_READ(RTC_FREQ_SELECT) & RTC_UIP); |
| kern_frestore(flags); |
| return uip; |
| } |
| |
| int get_rtc_time(struct rtc_time *rtc_tm) |
| { |
| SYS_FLAGS flags; |
| unsigned char ctrl; |
| unsigned retries=0; |
| struct timespec delay; |
| |
| /* |
| * read RTC once any update in progress is done. The update |
| * can take just over 2ms. We wait 10 to 20ms. There is no need to |
| * to poll-wait (up to 1s - eeccch) for the falling edge of RTC_UIP. |
| * If you need to know *exactly* when a second has started, enable |
| * periodic update complete interrupts, (via ioctl) and then |
| * immediately read /dev/rtc which will block until you get the IRQ. |
| * Once the read clears, read the RTC time (again via ioctl). Easy. |
| */ |
| |
| /* |
| if (rtc_is_updating() != 0) |
| while (jiffies - uip_watchdog < 2*HZ/100) |
| barrier(); |
| */ |
| |
| delay.tv_nsec = 1000000; |
| delay.tv_sec = 0; |
| while (rtc_is_updating()&&++retries<=5) nanosleep(&delay, NULL); |
| if (retries>5) return -1; |
| |
| /* |
| * Only the values that we read from the RTC are set. We leave |
| * tm_wday, tm_yday and tm_isdst untouched. Even though the |
| * RTC has RTC_DAY_OF_WEEK, we ignore it, as it is only updated |
| * by the RTC when initially set to a non-zero value. |
| */ |
| flags=kern_fsave(); |
| rtc_tm->tm_sec = CMOS_READ(RTC_SECONDS); |
| rtc_tm->tm_min = CMOS_READ(RTC_MINUTES); |
| rtc_tm->tm_hour = CMOS_READ(RTC_HOURS); |
| rtc_tm->tm_mday = CMOS_READ(RTC_DAY_OF_MONTH); |
| rtc_tm->tm_mon = CMOS_READ(RTC_MONTH); |
| rtc_tm->tm_year = CMOS_READ(RTC_YEAR); |
| ctrl = CMOS_READ(RTC_CONTROL); |
| kern_frestore(flags); |
| |
| if (!(ctrl & RTC_DM_BINARY) || RTC_ALWAYS_BCD) |
| { |
| BCD_TO_BIN(rtc_tm->tm_sec); |
| BCD_TO_BIN(rtc_tm->tm_min); |
| BCD_TO_BIN(rtc_tm->tm_hour); |
| BCD_TO_BIN(rtc_tm->tm_mday); |
| BCD_TO_BIN(rtc_tm->tm_mon); |
| BCD_TO_BIN(rtc_tm->tm_year); |
| } |
| |
| /* |
| * Account for differences between how the RTC uses the values |
| * and how they are defined in a struct rtc_time; |
| */ |
| if ((rtc_tm->tm_year += (epoch - 1900)) <= 69) |
| rtc_tm->tm_year += 100; |
| |
| rtc_tm->tm_mon--; |
| |
| return 0; |
| } |
| |
| int set_rtc_time(struct rtc_time *rtc_tm) |
| { |
| unsigned char mon, day, hrs, min, sec, leap_yr; |
| unsigned char save_control, save_freq_select; |
| unsigned int yrs; |
| SYS_FLAGS flags; |
| |
| 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; |
| |
| flags=kern_fsave(); |
| if (!(CMOS_READ(RTC_CONTROL) & RTC_DM_BINARY) |
| || RTC_ALWAYS_BCD) { |
| if (yrs > 169) { |
| kern_frestore(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); |
| |
| kern_frestore(flags); |
| |
| return 0; |
| } |
| |
| int get_rtc_alm_time(struct rtc_time *alm_tm) |
| { |
| SYS_FLAGS flags; |
| unsigned char ctrl; |
| |
| /* |
| * Only the values that we read from the RTC are set. That |
| * means only tm_hour, tm_min, and tm_sec. |
| */ |
| flags=kern_fsave(); |
| alm_tm->tm_sec = CMOS_READ(RTC_SECONDS_ALARM); |
| alm_tm->tm_min = CMOS_READ(RTC_MINUTES_ALARM); |
| alm_tm->tm_hour = CMOS_READ(RTC_HOURS_ALARM); |
| ctrl = CMOS_READ(RTC_CONTROL); |
| kern_frestore(flags); |
| |
| if (!(ctrl & RTC_DM_BINARY) || RTC_ALWAYS_BCD) |
| { |
| BCD_TO_BIN(alm_tm->tm_sec); |
| BCD_TO_BIN(alm_tm->tm_min); |
| BCD_TO_BIN(alm_tm->tm_hour); |
| } |
| |
| return 0; |
| } |
| |
| /* |
| * Used to disable/enable interrupts for any one of UIE, AIE, PIE. |
| * Rumour has it that if you frob the interrupt enable/disable |
| * bits in RTC_CONTROL, you should read RTC_INTR_FLAGS, to |
| * ensure you actually start getting interrupts. Probably for |
| * compatibility with older/broken chipset RTC implementations. |
| * We also clear out any old irq data after an ioctl() that |
| * meddles with the interrupt enable/disable bits. |
| */ |
| |
| void mask_rtc_irq_bit(unsigned char bit) |
| { |
| unsigned char val; |
| SYS_FLAGS flags; |
| |
| flags=kern_fsave(); |
| //cli(); |
| val = CMOS_READ(RTC_CONTROL); |
| val &= ~bit; |
| CMOS_WRITE(val, RTC_CONTROL); |
| CMOS_READ(RTC_INTR_FLAGS); |
| kern_frestore(flags); |
| //rtc_irq_data = 0; |
| } |
| |
| void set_rtc_irq_bit(unsigned char bit) |
| { |
| unsigned char val; |
| SYS_FLAGS flags; |
| |
| flags=kern_fsave(); |
| //cli(); |
| val = CMOS_READ(RTC_CONTROL); |
| val |= bit; |
| CMOS_WRITE(val, RTC_CONTROL); |
| CMOS_READ(RTC_INTR_FLAGS); |
| //rtc_irq_data = 0; |
| kern_frestore(flags); |
| } |
| |
| /* added by Massy */ |
| /* to find the date in seconds from the Epoch (1 Gen 1970 00:00 GMT) */ |
| /* (modifing a source from Linux) */ |
| |
| static int day_n[]={ |
| 0,31,59,90,120,151,181,212,243,273,304,334,0,0,0,0 |
| }; |
| |
| time_t sys_getdate(void) |
| { |
| struct rtc_time rtc; |
| time_t secs; |
| |
| get_rtc_time (&rtc); |
| |
| secs = rtc.tm_sec+60l*rtc.tm_min+rtc.tm_hour*3600l+86400l* |
| (rtc.tm_mday-1+day_n[rtc.tm_mon]+(rtc.tm_year/4l) |
| +rtc.tm_year*365l- |
| ((rtc.tm_year & 3) == 0 && rtc.tm_mon < 2 ? 1 : 0)+3653l); |
| |
| /* days since 1.1.70 plus 80's leap day */ |
| /*secs += sys_tz.tz_minuteswest*60;*/ |
| /*if (sys_tz.tz_dsttime) secs -= 3600;*/ |
| return secs; |
| } |