Merge git://github.com/davem330/net
[pandora-kernel.git] / arch / x86 / kernel / rtc.c
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);