]>
Commit | Line | Data |
---|---|---|
1da177e4 | 1 | /* |
1da177e4 LT |
2 | * (c) Copyright 2004 Benjamin Herrenschmidt (benh@kernel.crashing.org), |
3 | * IBM Corp. | |
4 | * | |
5 | * This program is free software; you can redistribute it and/or | |
6 | * modify it under the terms of the GNU General Public License | |
7 | * as published by the Free Software Foundation; either version | |
8 | * 2 of the License, or (at your option) any later version. | |
9 | * | |
10 | */ | |
11 | ||
12 | #undef DEBUG | |
13 | ||
14 | #include <linux/config.h> | |
15 | #include <linux/errno.h> | |
16 | #include <linux/sched.h> | |
17 | #include <linux/kernel.h> | |
18 | #include <linux/param.h> | |
19 | #include <linux/string.h> | |
20 | #include <linux/mm.h> | |
21 | #include <linux/init.h> | |
22 | #include <linux/time.h> | |
23 | #include <linux/adb.h> | |
24 | #include <linux/pmu.h> | |
25 | #include <linux/interrupt.h> | |
26 | #include <linux/mc146818rtc.h> | |
27 | #include <linux/bcd.h> | |
28 | ||
29 | #include <asm/sections.h> | |
30 | #include <asm/prom.h> | |
31 | #include <asm/system.h> | |
32 | #include <asm/io.h> | |
33 | #include <asm/pgtable.h> | |
34 | #include <asm/machdep.h> | |
35 | #include <asm/time.h> | |
36 | ||
0cb7b2af PM |
37 | #include "maple.h" |
38 | ||
1da177e4 LT |
39 | #ifdef DEBUG |
40 | #define DBG(x...) printk(x) | |
41 | #else | |
42 | #define DBG(x...) | |
43 | #endif | |
44 | ||
1da177e4 LT |
45 | extern void GregorianDay(struct rtc_time * tm); |
46 | ||
1da177e4 LT |
47 | static int maple_rtc_addr; |
48 | ||
49 | static int maple_clock_read(int addr) | |
50 | { | |
51 | outb_p(addr, maple_rtc_addr); | |
52 | return inb_p(maple_rtc_addr+1); | |
53 | } | |
54 | ||
55 | static void maple_clock_write(unsigned long val, int addr) | |
56 | { | |
57 | outb_p(addr, maple_rtc_addr); | |
58 | outb_p(val, maple_rtc_addr+1); | |
59 | } | |
60 | ||
61 | void maple_get_rtc_time(struct rtc_time *tm) | |
62 | { | |
63 | int uip, i; | |
64 | ||
65 | /* The Linux interpretation of the CMOS clock register contents: | |
66 | * When the Update-In-Progress (UIP) flag goes from 1 to 0, the | |
67 | * RTC registers show the second which has precisely just started. | |
68 | * Let's hope other operating systems interpret the RTC the same way. | |
69 | */ | |
70 | ||
71 | /* Since the UIP flag is set for about 2.2 ms and the clock | |
72 | * is typically written with a precision of 1 jiffy, trying | |
73 | * to obtain a precision better than a few milliseconds is | |
74 | * an illusion. Only consistency is interesting, this also | |
75 | * allows to use the routine for /dev/rtc without a potential | |
76 | * 1 second kernel busy loop triggered by any reader of /dev/rtc. | |
77 | */ | |
78 | ||
79 | for (i = 0; i<1000000; i++) { | |
80 | uip = maple_clock_read(RTC_FREQ_SELECT); | |
81 | tm->tm_sec = maple_clock_read(RTC_SECONDS); | |
82 | tm->tm_min = maple_clock_read(RTC_MINUTES); | |
83 | tm->tm_hour = maple_clock_read(RTC_HOURS); | |
84 | tm->tm_mday = maple_clock_read(RTC_DAY_OF_MONTH); | |
85 | tm->tm_mon = maple_clock_read(RTC_MONTH); | |
86 | tm->tm_year = maple_clock_read(RTC_YEAR); | |
87 | uip |= maple_clock_read(RTC_FREQ_SELECT); | |
88 | if ((uip & RTC_UIP)==0) | |
89 | break; | |
90 | } | |
91 | ||
92 | if (!(maple_clock_read(RTC_CONTROL) & RTC_DM_BINARY) | |
93 | || RTC_ALWAYS_BCD) { | |
94 | BCD_TO_BIN(tm->tm_sec); | |
95 | BCD_TO_BIN(tm->tm_min); | |
96 | BCD_TO_BIN(tm->tm_hour); | |
97 | BCD_TO_BIN(tm->tm_mday); | |
98 | BCD_TO_BIN(tm->tm_mon); | |
99 | BCD_TO_BIN(tm->tm_year); | |
100 | } | |
101 | if ((tm->tm_year + 1900) < 1970) | |
102 | tm->tm_year += 100; | |
103 | ||
104 | GregorianDay(tm); | |
105 | } | |
106 | ||
107 | int maple_set_rtc_time(struct rtc_time *tm) | |
108 | { | |
109 | unsigned char save_control, save_freq_select; | |
110 | int sec, min, hour, mon, mday, year; | |
111 | ||
112 | spin_lock(&rtc_lock); | |
113 | ||
114 | save_control = maple_clock_read(RTC_CONTROL); /* tell the clock it's being set */ | |
115 | ||
116 | maple_clock_write((save_control|RTC_SET), RTC_CONTROL); | |
117 | ||
118 | save_freq_select = maple_clock_read(RTC_FREQ_SELECT); /* stop and reset prescaler */ | |
119 | ||
120 | maple_clock_write((save_freq_select|RTC_DIV_RESET2), RTC_FREQ_SELECT); | |
121 | ||
122 | sec = tm->tm_sec; | |
123 | min = tm->tm_min; | |
124 | hour = tm->tm_hour; | |
125 | mon = tm->tm_mon; | |
126 | mday = tm->tm_mday; | |
127 | year = tm->tm_year; | |
128 | ||
129 | if (!(save_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD) { | |
130 | BIN_TO_BCD(sec); | |
131 | BIN_TO_BCD(min); | |
132 | BIN_TO_BCD(hour); | |
133 | BIN_TO_BCD(mon); | |
134 | BIN_TO_BCD(mday); | |
135 | BIN_TO_BCD(year); | |
136 | } | |
137 | maple_clock_write(sec, RTC_SECONDS); | |
138 | maple_clock_write(min, RTC_MINUTES); | |
139 | maple_clock_write(hour, RTC_HOURS); | |
140 | maple_clock_write(mon, RTC_MONTH); | |
141 | maple_clock_write(mday, RTC_DAY_OF_MONTH); | |
142 | maple_clock_write(year, RTC_YEAR); | |
143 | ||
144 | /* The following flags have to be released exactly in this order, | |
145 | * otherwise the DS12887 (popular MC146818A clone with integrated | |
146 | * battery and quartz) will not reset the oscillator and will not | |
147 | * update precisely 500 ms later. You won't find this mentioned in | |
148 | * the Dallas Semiconductor data sheets, but who believes data | |
149 | * sheets anyway ... -- Markus Kuhn | |
150 | */ | |
151 | maple_clock_write(save_control, RTC_CONTROL); | |
152 | maple_clock_write(save_freq_select, RTC_FREQ_SELECT); | |
153 | ||
154 | spin_unlock(&rtc_lock); | |
155 | ||
156 | return 0; | |
157 | } | |
158 | ||
a097a35c SB |
159 | static struct resource rtc_iores = { |
160 | .name = "rtc", | |
161 | .flags = IORESOURCE_BUSY, | |
162 | }; | |
163 | ||
143a1dec | 164 | unsigned long __init maple_get_boot_time(void) |
1da177e4 | 165 | { |
143a1dec | 166 | struct rtc_time tm; |
1da177e4 LT |
167 | struct device_node *rtcs; |
168 | ||
4c882b01 BH |
169 | rtcs = of_find_compatible_node(NULL, "rtc", "pnpPNP,b00"); |
170 | if (rtcs) { | |
171 | struct resource r; | |
172 | if (of_address_to_resource(rtcs, 0, &r)) { | |
173 | printk(KERN_EMERG "Maple: Unable to translate RTC" | |
174 | " address\n"); | |
175 | goto bail; | |
176 | } | |
177 | if (!(r.flags & IORESOURCE_IO)) { | |
178 | printk(KERN_EMERG "Maple: RTC address isn't PIO!\n"); | |
179 | goto bail; | |
180 | } | |
181 | maple_rtc_addr = r.start; | |
182 | printk(KERN_INFO "Maple: Found RTC at IO 0x%x\n", | |
183 | maple_rtc_addr); | |
184 | } | |
185 | bail: | |
186 | if (maple_rtc_addr == 0) { | |
1da177e4 LT |
187 | maple_rtc_addr = RTC_PORT(0); /* legacy address */ |
188 | printk(KERN_INFO "Maple: No device node for RTC, assuming " | |
189 | "legacy address (0x%x)\n", maple_rtc_addr); | |
190 | } | |
a097a35c SB |
191 | |
192 | rtc_iores.start = maple_rtc_addr; | |
193 | rtc_iores.end = maple_rtc_addr + 7; | |
194 | request_resource(&ioport_resource, &rtc_iores); | |
195 | ||
143a1dec | 196 | maple_get_rtc_time(&tm); |
17a6392d PM |
197 | return mktime(tm.tm_year+1900, tm.tm_mon+1, tm.tm_mday, |
198 | tm.tm_hour, tm.tm_min, tm.tm_sec); | |
1da177e4 LT |
199 | } |
200 |