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