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