xref: /openbmc/linux/arch/m68k/atari/time.c (revision 95298d63) 
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 
25 DEFINE_SPINLOCK(rtc_lock);
26 EXPORT_SYMBOL_GPL(rtc_lock);
27 
28 static u64 atari_read_clk(struct clocksource *cs);
29 
30 static 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 
38 static u32 clk_total;
39 static u8 last_timer_count;
40 
41 static 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 
57 void __init
58 atari_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 
74 static 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 
95 static 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 
109 static 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 
139 int 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 
198 int 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  */
326