Loading...
1/*
2 * linux/arch/m68k/atari/time.c
3 *
4 * Atari time and real time clock stuff
5 *
6 * Assembled of parts of former atari/config.c 97-12-18 by Roman Hodek
7 *
8 * This file is subject to the terms and conditions of the GNU General Public
9 * License. See the file COPYING in the main directory of this archive
10 * for more details.
11 */
12
13#include <linux/types.h>
14#include <linux/mc146818rtc.h>
15#include <linux/interrupt.h>
16#include <linux/init.h>
17#include <linux/rtc.h>
18#include <linux/bcd.h>
19#include <linux/clocksource.h>
20#include <linux/delay.h>
21#include <linux/export.h>
22
23#include <asm/atariints.h>
24#include <asm/machdep.h>
25
26DEFINE_SPINLOCK(rtc_lock);
27EXPORT_SYMBOL_GPL(rtc_lock);
28
29static u64 atari_read_clk(struct clocksource *cs);
30
31static struct clocksource atari_clk = {
32 .name = "mfp",
33 .rating = 100,
34 .read = atari_read_clk,
35 .mask = CLOCKSOURCE_MASK(32),
36 .flags = CLOCK_SOURCE_IS_CONTINUOUS,
37};
38
39static u32 clk_total;
40static u8 last_timer_count;
41
42static irqreturn_t mfp_timer_c_handler(int irq, void *dev_id)
43{
44 unsigned long flags;
45
46 local_irq_save(flags);
47 do {
48 last_timer_count = st_mfp.tim_dt_c;
49 } while (last_timer_count == 1);
50 clk_total += INT_TICKS;
51 legacy_timer_tick(1);
52 timer_heartbeat();
53 local_irq_restore(flags);
54
55 return IRQ_HANDLED;
56}
57
58void __init
59atari_sched_init(void)
60{
61 /* set Timer C data Register */
62 st_mfp.tim_dt_c = INT_TICKS;
63 /* start timer C, div = 1:100 */
64 st_mfp.tim_ct_cd = (st_mfp.tim_ct_cd & 15) | 0x60;
65 /* install interrupt service routine for MFP Timer C */
66 if (request_irq(IRQ_MFP_TIMC, mfp_timer_c_handler, IRQF_TIMER, "timer",
67 NULL))
68 pr_err("Couldn't register timer interrupt\n");
69
70 clocksource_register_hz(&atari_clk, INT_CLK);
71}
72
73/* ++andreas: gettimeoffset fixed to check for pending interrupt */
74
75static u64 atari_read_clk(struct clocksource *cs)
76{
77 unsigned long flags;
78 u8 count;
79 u32 ticks;
80
81 local_irq_save(flags);
82 /* Ensure that the count is monotonically decreasing, even though
83 * the result may briefly stop changing after counter wrap-around.
84 */
85 count = min(st_mfp.tim_dt_c, last_timer_count);
86 last_timer_count = count;
87
88 ticks = INT_TICKS - count;
89 ticks += clk_total;
90 local_irq_restore(flags);
91
92 return ticks;
93}
94
95
96static void mste_read(struct MSTE_RTC *val)
97{
98#define COPY(v) val->v=(mste_rtc.v & 0xf)
99 do {
100 COPY(sec_ones) ; COPY(sec_tens) ; COPY(min_ones) ;
101 COPY(min_tens) ; COPY(hr_ones) ; COPY(hr_tens) ;
102 COPY(weekday) ; COPY(day_ones) ; COPY(day_tens) ;
103 COPY(mon_ones) ; COPY(mon_tens) ; COPY(year_ones) ;
104 COPY(year_tens) ;
105 /* prevent from reading the clock while it changed */
106 } while (val->sec_ones != (mste_rtc.sec_ones & 0xf));
107#undef COPY
108}
109
110static void mste_write(struct MSTE_RTC *val)
111{
112#define COPY(v) mste_rtc.v=val->v
113 do {
114 COPY(sec_ones) ; COPY(sec_tens) ; COPY(min_ones) ;
115 COPY(min_tens) ; COPY(hr_ones) ; COPY(hr_tens) ;
116 COPY(weekday) ; COPY(day_ones) ; COPY(day_tens) ;
117 COPY(mon_ones) ; COPY(mon_tens) ; COPY(year_ones) ;
118 COPY(year_tens) ;
119 /* prevent from writing the clock while it changed */
120 } while (val->sec_ones != (mste_rtc.sec_ones & 0xf));
121#undef COPY
122}
123
124#define RTC_READ(reg) \
125 ({ unsigned char __val; \
126 (void) atari_writeb(reg,&tt_rtc.regsel); \
127 __val = tt_rtc.data; \
128 __val; \
129 })
130
131#define RTC_WRITE(reg,val) \
132 do { \
133 atari_writeb(reg,&tt_rtc.regsel); \
134 tt_rtc.data = (val); \
135 } while(0)
136
137
138#define HWCLK_POLL_INTERVAL 5
139
140int atari_mste_hwclk( int op, struct rtc_time *t )
141{
142 int hour, year;
143 int hr24=0;
144 struct MSTE_RTC val;
145
146 mste_rtc.mode=(mste_rtc.mode | 1);
147 hr24=mste_rtc.mon_tens & 1;
148 mste_rtc.mode=(mste_rtc.mode & ~1);
149
150 if (op) {
151 /* write: prepare values */
152
153 val.sec_ones = t->tm_sec % 10;
154 val.sec_tens = t->tm_sec / 10;
155 val.min_ones = t->tm_min % 10;
156 val.min_tens = t->tm_min / 10;
157 hour = t->tm_hour;
158 if (!hr24) {
159 if (hour > 11)
160 hour += 20 - 12;
161 if (hour == 0 || hour == 20)
162 hour += 12;
163 }
164 val.hr_ones = hour % 10;
165 val.hr_tens = hour / 10;
166 val.day_ones = t->tm_mday % 10;
167 val.day_tens = t->tm_mday / 10;
168 val.mon_ones = (t->tm_mon+1) % 10;
169 val.mon_tens = (t->tm_mon+1) / 10;
170 year = t->tm_year - 80;
171 val.year_ones = year % 10;
172 val.year_tens = year / 10;
173 val.weekday = t->tm_wday;
174 mste_write(&val);
175 mste_rtc.mode=(mste_rtc.mode | 1);
176 val.year_ones = (year % 4); /* leap year register */
177 mste_rtc.mode=(mste_rtc.mode & ~1);
178 }
179 else {
180 mste_read(&val);
181 t->tm_sec = val.sec_ones + val.sec_tens * 10;
182 t->tm_min = val.min_ones + val.min_tens * 10;
183 hour = val.hr_ones + val.hr_tens * 10;
184 if (!hr24) {
185 if (hour == 12 || hour == 12 + 20)
186 hour -= 12;
187 if (hour >= 20)
188 hour += 12 - 20;
189 }
190 t->tm_hour = hour;
191 t->tm_mday = val.day_ones + val.day_tens * 10;
192 t->tm_mon = val.mon_ones + val.mon_tens * 10 - 1;
193 t->tm_year = val.year_ones + val.year_tens * 10 + 80;
194 t->tm_wday = val.weekday;
195 }
196 return 0;
197}
198
199int atari_tt_hwclk( int op, struct rtc_time *t )
200{
201 int sec=0, min=0, hour=0, day=0, mon=0, year=0, wday=0;
202 unsigned long flags;
203 unsigned char ctrl;
204 int pm = 0;
205
206 ctrl = RTC_READ(RTC_CONTROL); /* control registers are
207 * independent from the UIP */
208
209 if (op) {
210 /* write: prepare values */
211
212 sec = t->tm_sec;
213 min = t->tm_min;
214 hour = t->tm_hour;
215 day = t->tm_mday;
216 mon = t->tm_mon + 1;
217 year = t->tm_year - atari_rtc_year_offset;
218 wday = t->tm_wday + (t->tm_wday >= 0);
219
220 if (!(ctrl & RTC_24H)) {
221 if (hour > 11) {
222 pm = 0x80;
223 if (hour != 12)
224 hour -= 12;
225 }
226 else if (hour == 0)
227 hour = 12;
228 }
229
230 if (!(ctrl & RTC_DM_BINARY)) {
231 sec = bin2bcd(sec);
232 min = bin2bcd(min);
233 hour = bin2bcd(hour);
234 day = bin2bcd(day);
235 mon = bin2bcd(mon);
236 year = bin2bcd(year);
237 if (wday >= 0)
238 wday = bin2bcd(wday);
239 }
240 }
241
242 /* Reading/writing the clock registers is a bit critical due to
243 * the regular update cycle of the RTC. While an update is in
244 * progress, registers 0..9 shouldn't be touched.
245 * The problem is solved like that: If an update is currently in
246 * progress (the UIP bit is set), the process sleeps for a while
247 * (50ms). This really should be enough, since the update cycle
248 * normally needs 2 ms.
249 * If the UIP bit reads as 0, we have at least 244 usecs until the
250 * update starts. This should be enough... But to be sure,
251 * additionally the RTC_SET bit is set to prevent an update cycle.
252 */
253
254 while( RTC_READ(RTC_FREQ_SELECT) & RTC_UIP ) {
255 if (in_atomic() || irqs_disabled())
256 mdelay(1);
257 else
258 schedule_timeout_interruptible(HWCLK_POLL_INTERVAL);
259 }
260
261 local_irq_save(flags);
262 RTC_WRITE( RTC_CONTROL, ctrl | RTC_SET );
263 if (!op) {
264 sec = RTC_READ( RTC_SECONDS );
265 min = RTC_READ( RTC_MINUTES );
266 hour = RTC_READ( RTC_HOURS );
267 day = RTC_READ( RTC_DAY_OF_MONTH );
268 mon = RTC_READ( RTC_MONTH );
269 year = RTC_READ( RTC_YEAR );
270 wday = RTC_READ( RTC_DAY_OF_WEEK );
271 }
272 else {
273 RTC_WRITE( RTC_SECONDS, sec );
274 RTC_WRITE( RTC_MINUTES, min );
275 RTC_WRITE( RTC_HOURS, hour + pm);
276 RTC_WRITE( RTC_DAY_OF_MONTH, day );
277 RTC_WRITE( RTC_MONTH, mon );
278 RTC_WRITE( RTC_YEAR, year );
279 if (wday >= 0) RTC_WRITE( RTC_DAY_OF_WEEK, wday );
280 }
281 RTC_WRITE( RTC_CONTROL, ctrl & ~RTC_SET );
282 local_irq_restore(flags);
283
284 if (!op) {
285 /* read: adjust values */
286
287 if (hour & 0x80) {
288 hour &= ~0x80;
289 pm = 1;
290 }
291
292 if (!(ctrl & RTC_DM_BINARY)) {
293 sec = bcd2bin(sec);
294 min = bcd2bin(min);
295 hour = bcd2bin(hour);
296 day = bcd2bin(day);
297 mon = bcd2bin(mon);
298 year = bcd2bin(year);
299 wday = bcd2bin(wday);
300 }
301
302 if (!(ctrl & RTC_24H)) {
303 if (!pm && hour == 12)
304 hour = 0;
305 else if (pm && hour != 12)
306 hour += 12;
307 }
308
309 t->tm_sec = sec;
310 t->tm_min = min;
311 t->tm_hour = hour;
312 t->tm_mday = day;
313 t->tm_mon = mon - 1;
314 t->tm_year = year + atari_rtc_year_offset;
315 t->tm_wday = wday - 1;
316 }
317
318 return( 0 );
319}
1/*
2 * linux/arch/m68k/atari/time.c
3 *
4 * Atari time and real time clock stuff
5 *
6 * Assembled of parts of former atari/config.c 97-12-18 by Roman Hodek
7 *
8 * This file is subject to the terms and conditions of the GNU General Public
9 * License. See the file COPYING in the main directory of this archive
10 * for more details.
11 */
12
13#include <linux/types.h>
14#include <linux/mc146818rtc.h>
15#include <linux/interrupt.h>
16#include <linux/init.h>
17#include <linux/rtc.h>
18#include <linux/bcd.h>
19#include <linux/clocksource.h>
20#include <linux/delay.h>
21#include <linux/export.h>
22
23#include <asm/atariints.h>
24
25DEFINE_SPINLOCK(rtc_lock);
26EXPORT_SYMBOL_GPL(rtc_lock);
27
28static u64 atari_read_clk(struct clocksource *cs);
29
30static struct clocksource atari_clk = {
31 .name = "mfp",
32 .rating = 100,
33 .read = atari_read_clk,
34 .mask = CLOCKSOURCE_MASK(32),
35 .flags = CLOCK_SOURCE_IS_CONTINUOUS,
36};
37
38static u32 clk_total;
39static u8 last_timer_count;
40
41static irqreturn_t mfp_timer_c_handler(int irq, void *dev_id)
42{
43 irq_handler_t timer_routine = dev_id;
44 unsigned long flags;
45
46 local_irq_save(flags);
47 do {
48 last_timer_count = st_mfp.tim_dt_c;
49 } while (last_timer_count == 1);
50 clk_total += INT_TICKS;
51 timer_routine(0, NULL);
52 local_irq_restore(flags);
53
54 return IRQ_HANDLED;
55}
56
57void __init
58atari_sched_init(irq_handler_t timer_routine)
59{
60 /* set Timer C data Register */
61 st_mfp.tim_dt_c = INT_TICKS;
62 /* start timer C, div = 1:100 */
63 st_mfp.tim_ct_cd = (st_mfp.tim_ct_cd & 15) | 0x60;
64 /* install interrupt service routine for MFP Timer C */
65 if (request_irq(IRQ_MFP_TIMC, mfp_timer_c_handler, IRQF_TIMER, "timer",
66 timer_routine))
67 pr_err("Couldn't register timer interrupt\n");
68
69 clocksource_register_hz(&atari_clk, INT_CLK);
70}
71
72/* ++andreas: gettimeoffset fixed to check for pending interrupt */
73
74static u64 atari_read_clk(struct clocksource *cs)
75{
76 unsigned long flags;
77 u8 count;
78 u32 ticks;
79
80 local_irq_save(flags);
81 /* Ensure that the count is monotonically decreasing, even though
82 * the result may briefly stop changing after counter wrap-around.
83 */
84 count = min(st_mfp.tim_dt_c, last_timer_count);
85 last_timer_count = count;
86
87 ticks = INT_TICKS - count;
88 ticks += clk_total;
89 local_irq_restore(flags);
90
91 return ticks;
92}
93
94
95static void mste_read(struct MSTE_RTC *val)
96{
97#define COPY(v) val->v=(mste_rtc.v & 0xf)
98 do {
99 COPY(sec_ones) ; COPY(sec_tens) ; COPY(min_ones) ;
100 COPY(min_tens) ; COPY(hr_ones) ; COPY(hr_tens) ;
101 COPY(weekday) ; COPY(day_ones) ; COPY(day_tens) ;
102 COPY(mon_ones) ; COPY(mon_tens) ; COPY(year_ones) ;
103 COPY(year_tens) ;
104 /* prevent from reading the clock while it changed */
105 } while (val->sec_ones != (mste_rtc.sec_ones & 0xf));
106#undef COPY
107}
108
109static void mste_write(struct MSTE_RTC *val)
110{
111#define COPY(v) mste_rtc.v=val->v
112 do {
113 COPY(sec_ones) ; COPY(sec_tens) ; COPY(min_ones) ;
114 COPY(min_tens) ; COPY(hr_ones) ; COPY(hr_tens) ;
115 COPY(weekday) ; COPY(day_ones) ; COPY(day_tens) ;
116 COPY(mon_ones) ; COPY(mon_tens) ; COPY(year_ones) ;
117 COPY(year_tens) ;
118 /* prevent from writing the clock while it changed */
119 } while (val->sec_ones != (mste_rtc.sec_ones & 0xf));
120#undef COPY
121}
122
123#define RTC_READ(reg) \
124 ({ unsigned char __val; \
125 (void) atari_writeb(reg,&tt_rtc.regsel); \
126 __val = tt_rtc.data; \
127 __val; \
128 })
129
130#define RTC_WRITE(reg,val) \
131 do { \
132 atari_writeb(reg,&tt_rtc.regsel); \
133 tt_rtc.data = (val); \
134 } while(0)
135
136
137#define HWCLK_POLL_INTERVAL 5
138
139int atari_mste_hwclk( int op, struct rtc_time *t )
140{
141 int hour, year;
142 int hr24=0;
143 struct MSTE_RTC val;
144
145 mste_rtc.mode=(mste_rtc.mode | 1);
146 hr24=mste_rtc.mon_tens & 1;
147 mste_rtc.mode=(mste_rtc.mode & ~1);
148
149 if (op) {
150 /* write: prepare values */
151
152 val.sec_ones = t->tm_sec % 10;
153 val.sec_tens = t->tm_sec / 10;
154 val.min_ones = t->tm_min % 10;
155 val.min_tens = t->tm_min / 10;
156 hour = t->tm_hour;
157 if (!hr24) {
158 if (hour > 11)
159 hour += 20 - 12;
160 if (hour == 0 || hour == 20)
161 hour += 12;
162 }
163 val.hr_ones = hour % 10;
164 val.hr_tens = hour / 10;
165 val.day_ones = t->tm_mday % 10;
166 val.day_tens = t->tm_mday / 10;
167 val.mon_ones = (t->tm_mon+1) % 10;
168 val.mon_tens = (t->tm_mon+1) / 10;
169 year = t->tm_year - 80;
170 val.year_ones = year % 10;
171 val.year_tens = year / 10;
172 val.weekday = t->tm_wday;
173 mste_write(&val);
174 mste_rtc.mode=(mste_rtc.mode | 1);
175 val.year_ones = (year % 4); /* leap year register */
176 mste_rtc.mode=(mste_rtc.mode & ~1);
177 }
178 else {
179 mste_read(&val);
180 t->tm_sec = val.sec_ones + val.sec_tens * 10;
181 t->tm_min = val.min_ones + val.min_tens * 10;
182 hour = val.hr_ones + val.hr_tens * 10;
183 if (!hr24) {
184 if (hour == 12 || hour == 12 + 20)
185 hour -= 12;
186 if (hour >= 20)
187 hour += 12 - 20;
188 }
189 t->tm_hour = hour;
190 t->tm_mday = val.day_ones + val.day_tens * 10;
191 t->tm_mon = val.mon_ones + val.mon_tens * 10 - 1;
192 t->tm_year = val.year_ones + val.year_tens * 10 + 80;
193 t->tm_wday = val.weekday;
194 }
195 return 0;
196}
197
198int atari_tt_hwclk( int op, struct rtc_time *t )
199{
200 int sec=0, min=0, hour=0, day=0, mon=0, year=0, wday=0;
201 unsigned long flags;
202 unsigned char ctrl;
203 int pm = 0;
204
205 ctrl = RTC_READ(RTC_CONTROL); /* control registers are
206 * independent from the UIP */
207
208 if (op) {
209 /* write: prepare values */
210
211 sec = t->tm_sec;
212 min = t->tm_min;
213 hour = t->tm_hour;
214 day = t->tm_mday;
215 mon = t->tm_mon + 1;
216 year = t->tm_year - atari_rtc_year_offset;
217 wday = t->tm_wday + (t->tm_wday >= 0);
218
219 if (!(ctrl & RTC_24H)) {
220 if (hour > 11) {
221 pm = 0x80;
222 if (hour != 12)
223 hour -= 12;
224 }
225 else if (hour == 0)
226 hour = 12;
227 }
228
229 if (!(ctrl & RTC_DM_BINARY)) {
230 sec = bin2bcd(sec);
231 min = bin2bcd(min);
232 hour = bin2bcd(hour);
233 day = bin2bcd(day);
234 mon = bin2bcd(mon);
235 year = bin2bcd(year);
236 if (wday >= 0)
237 wday = bin2bcd(wday);
238 }
239 }
240
241 /* Reading/writing the clock registers is a bit critical due to
242 * the regular update cycle of the RTC. While an update is in
243 * progress, registers 0..9 shouldn't be touched.
244 * The problem is solved like that: If an update is currently in
245 * progress (the UIP bit is set), the process sleeps for a while
246 * (50ms). This really should be enough, since the update cycle
247 * normally needs 2 ms.
248 * If the UIP bit reads as 0, we have at least 244 usecs until the
249 * update starts. This should be enough... But to be sure,
250 * additionally the RTC_SET bit is set to prevent an update cycle.
251 */
252
253 while( RTC_READ(RTC_FREQ_SELECT) & RTC_UIP ) {
254 if (in_atomic() || irqs_disabled())
255 mdelay(1);
256 else
257 schedule_timeout_interruptible(HWCLK_POLL_INTERVAL);
258 }
259
260 local_irq_save(flags);
261 RTC_WRITE( RTC_CONTROL, ctrl | RTC_SET );
262 if (!op) {
263 sec = RTC_READ( RTC_SECONDS );
264 min = RTC_READ( RTC_MINUTES );
265 hour = RTC_READ( RTC_HOURS );
266 day = RTC_READ( RTC_DAY_OF_MONTH );
267 mon = RTC_READ( RTC_MONTH );
268 year = RTC_READ( RTC_YEAR );
269 wday = RTC_READ( RTC_DAY_OF_WEEK );
270 }
271 else {
272 RTC_WRITE( RTC_SECONDS, sec );
273 RTC_WRITE( RTC_MINUTES, min );
274 RTC_WRITE( RTC_HOURS, hour + pm);
275 RTC_WRITE( RTC_DAY_OF_MONTH, day );
276 RTC_WRITE( RTC_MONTH, mon );
277 RTC_WRITE( RTC_YEAR, year );
278 if (wday >= 0) RTC_WRITE( RTC_DAY_OF_WEEK, wday );
279 }
280 RTC_WRITE( RTC_CONTROL, ctrl & ~RTC_SET );
281 local_irq_restore(flags);
282
283 if (!op) {
284 /* read: adjust values */
285
286 if (hour & 0x80) {
287 hour &= ~0x80;
288 pm = 1;
289 }
290
291 if (!(ctrl & RTC_DM_BINARY)) {
292 sec = bcd2bin(sec);
293 min = bcd2bin(min);
294 hour = bcd2bin(hour);
295 day = bcd2bin(day);
296 mon = bcd2bin(mon);
297 year = bcd2bin(year);
298 wday = bcd2bin(wday);
299 }
300
301 if (!(ctrl & RTC_24H)) {
302 if (!pm && hour == 12)
303 hour = 0;
304 else if (pm && hour != 12)
305 hour += 12;
306 }
307
308 t->tm_sec = sec;
309 t->tm_min = min;
310 t->tm_hour = hour;
311 t->tm_mday = day;
312 t->tm_mon = mon - 1;
313 t->tm_year = year + atari_rtc_year_offset;
314 t->tm_wday = wday - 1;
315 }
316
317 return( 0 );
318}
319
320/*
321 * Local variables:
322 * c-indent-level: 4
323 * tab-width: 8
324 * End:
325 */