1 /* 2 * RTC related functions 3 */ 4 #include <linux/acpi.h> 5 #include <linux/bcd.h> 6 #include <linux/mc146818rtc.h> 7 8 #include <asm/time.h> 9 #include <asm/vsyscall.h> 10 11 #ifdef CONFIG_X86_32 12 # define CMOS_YEARS_OFFS 1900 13 /* 14 * This is a special lock that is owned by the CPU and holds the index 15 * register we are working with. It is required for NMI access to the 16 * CMOS/RTC registers. See include/asm-i386/mc146818rtc.h for details. 17 */ 18 volatile unsigned long cmos_lock = 0; 19 EXPORT_SYMBOL(cmos_lock); 20 #else 21 /* 22 * x86-64 systems only exists since 2002. 23 * This will work up to Dec 31, 2100 24 */ 25 # define CMOS_YEARS_OFFS 2000 26 #endif 27 28 DEFINE_SPINLOCK(rtc_lock); 29 EXPORT_SYMBOL(rtc_lock); 30 31 /* 32 * In order to set the CMOS clock precisely, set_rtc_mmss has to be 33 * called 500 ms after the second nowtime has started, because when 34 * nowtime is written into the registers of the CMOS clock, it will 35 * jump to the next second precisely 500 ms later. Check the Motorola 36 * MC146818A or Dallas DS12887 data sheet for details. 37 * 38 * BUG: This routine does not handle hour overflow properly; it just 39 * sets the minutes. Usually you'll only notice that after reboot! 40 */ 41 int mach_set_rtc_mmss(unsigned long nowtime) 42 { 43 int retval = 0; 44 int real_seconds, real_minutes, cmos_minutes; 45 unsigned char save_control, save_freq_select; 46 47 /* tell the clock it's being set */ 48 save_control = CMOS_READ(RTC_CONTROL); 49 CMOS_WRITE((save_control|RTC_SET), RTC_CONTROL); 50 51 /* stop and reset prescaler */ 52 save_freq_select = CMOS_READ(RTC_FREQ_SELECT); 53 CMOS_WRITE((save_freq_select|RTC_DIV_RESET2), RTC_FREQ_SELECT); 54 55 cmos_minutes = CMOS_READ(RTC_MINUTES); 56 if (!(save_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD) 57 BCD_TO_BIN(cmos_minutes); 58 59 /* 60 * since we're only adjusting minutes and seconds, 61 * don't interfere with hour overflow. This avoids 62 * messing with unknown time zones but requires your 63 * RTC not to be off by more than 15 minutes 64 */ 65 real_seconds = nowtime % 60; 66 real_minutes = nowtime / 60; 67 /* correct for half hour time zone */ 68 if (((abs(real_minutes - cmos_minutes) + 15)/30) & 1) 69 real_minutes += 30; 70 real_minutes %= 60; 71 72 if (abs(real_minutes - cmos_minutes) < 30) { 73 if (!(save_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD) { 74 BIN_TO_BCD(real_seconds); 75 BIN_TO_BCD(real_minutes); 76 } 77 CMOS_WRITE(real_seconds,RTC_SECONDS); 78 CMOS_WRITE(real_minutes,RTC_MINUTES); 79 } else { 80 printk(KERN_WARNING 81 "set_rtc_mmss: can't update from %d to %d\n", 82 cmos_minutes, real_minutes); 83 retval = -1; 84 } 85 86 /* The following flags have to be released exactly in this order, 87 * otherwise the DS12887 (popular MC146818A clone with integrated 88 * battery and quartz) will not reset the oscillator and will not 89 * update precisely 500 ms later. You won't find this mentioned in 90 * the Dallas Semiconductor data sheets, but who believes data 91 * sheets anyway ... -- Markus Kuhn 92 */ 93 CMOS_WRITE(save_control, RTC_CONTROL); 94 CMOS_WRITE(save_freq_select, RTC_FREQ_SELECT); 95 96 return retval; 97 } 98 99 unsigned long mach_get_cmos_time(void) 100 { 101 unsigned int year, mon, day, hour, min, sec, century = 0; 102 103 /* 104 * If UIP is clear, then we have >= 244 microseconds before 105 * RTC registers will be updated. Spec sheet says that this 106 * is the reliable way to read RTC - registers. If UIP is set 107 * then the register access might be invalid. 108 */ 109 while ((CMOS_READ(RTC_FREQ_SELECT) & RTC_UIP)) 110 cpu_relax(); 111 112 sec = CMOS_READ(RTC_SECONDS); 113 min = CMOS_READ(RTC_MINUTES); 114 hour = CMOS_READ(RTC_HOURS); 115 day = CMOS_READ(RTC_DAY_OF_MONTH); 116 mon = CMOS_READ(RTC_MONTH); 117 year = CMOS_READ(RTC_YEAR); 118 119 #if defined(CONFIG_ACPI) && defined(CONFIG_X86_64) 120 /* CHECKME: Is this really 64bit only ??? */ 121 if (acpi_gbl_FADT.header.revision >= FADT2_REVISION_ID && 122 acpi_gbl_FADT.century) 123 century = CMOS_READ(acpi_gbl_FADT.century); 124 #endif 125 126 if (RTC_ALWAYS_BCD || !(CMOS_READ(RTC_CONTROL) & RTC_DM_BINARY)) { 127 BCD_TO_BIN(sec); 128 BCD_TO_BIN(min); 129 BCD_TO_BIN(hour); 130 BCD_TO_BIN(day); 131 BCD_TO_BIN(mon); 132 BCD_TO_BIN(year); 133 } 134 135 if (century) { 136 BCD_TO_BIN(century); 137 year += century * 100; 138 printk(KERN_INFO "Extended CMOS year: %d\n", century * 100); 139 } else { 140 year += CMOS_YEARS_OFFS; 141 if (year < 1970) 142 year += 100; 143 } 144 145 return mktime(year, mon, day, hour, min, sec); 146 } 147 148 /* Routines for accessing the CMOS RAM/RTC. */ 149 unsigned char rtc_cmos_read(unsigned char addr) 150 { 151 unsigned char val; 152 153 lock_cmos_prefix(addr); 154 outb_p(addr, RTC_PORT(0)); 155 val = inb_p(RTC_PORT(1)); 156 lock_cmos_suffix(addr); 157 return val; 158 } 159 EXPORT_SYMBOL(rtc_cmos_read); 160 161 void rtc_cmos_write(unsigned char val, unsigned char addr) 162 { 163 lock_cmos_prefix(addr); 164 outb_p(addr, RTC_PORT(0)); 165 outb_p(val, RTC_PORT(1)); 166 lock_cmos_suffix(addr); 167 } 168 EXPORT_SYMBOL(rtc_cmos_write); 169 170 static int set_rtc_mmss(unsigned long nowtime) 171 { 172 int retval; 173 unsigned long flags; 174 175 spin_lock_irqsave(&rtc_lock, flags); 176 retval = set_wallclock(nowtime); 177 spin_unlock_irqrestore(&rtc_lock, flags); 178 179 return retval; 180 } 181 182 /* not static: needed by APM */ 183 unsigned long read_persistent_clock(void) 184 { 185 unsigned long retval, flags; 186 187 spin_lock_irqsave(&rtc_lock, flags); 188 retval = get_wallclock(); 189 spin_unlock_irqrestore(&rtc_lock, flags); 190 191 return retval; 192 } 193 194 int update_persistent_clock(struct timespec now) 195 { 196 return set_rtc_mmss(now.tv_sec); 197 } 198 199 unsigned long long native_read_tsc(void) 200 { 201 return __native_read_tsc(); 202 } 203 EXPORT_SYMBOL(native_read_tsc); 204 205