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