Merge branch 'x86-platform-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...
[linux-2.6.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
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  */
20 volatile unsigned long cmos_lock;
21 EXPORT_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
27 DEFINE_SPINLOCK(rtc_lock);
28 EXPORT_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  */
40 int 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
98 unsigned 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. */
147 unsigned 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 }
158 EXPORT_SYMBOL(rtc_cmos_read);
159
160 void 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 }
167 EXPORT_SYMBOL(rtc_cmos_write);
168
169 int 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 */
182 void 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
194 unsigned long long native_read_tsc(void)
195 {
196         return __native_read_tsc();
197 }
198 EXPORT_SYMBOL(native_read_tsc);
199
200
201 static 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
214 static 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
221 static __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 }
246 device_initcall(add_rtc_cmos);