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/delay.h> 20 21 #include <asm/atariints.h> 22 23 void __init 24 atari_sched_init(irq_handler_t timer_routine) 25 { 26 /* set Timer C data Register */ 27 mfp.tim_dt_c = INT_TICKS; 28 /* start timer C, div = 1:100 */ 29 mfp.tim_ct_cd = (mfp.tim_ct_cd & 15) | 0x60; 30 /* install interrupt service routine for MFP Timer C */ 31 request_irq(IRQ_MFP_TIMC, timer_routine, IRQ_TYPE_SLOW, 32 "timer", timer_routine); 33 } 34 35 /* ++andreas: gettimeoffset fixed to check for pending interrupt */ 36 37 #define TICK_SIZE 10000 38 39 /* This is always executed with interrupts disabled. */ 40 unsigned long atari_gettimeoffset (void) 41 { 42 unsigned long ticks, offset = 0; 43 44 /* read MFP timer C current value */ 45 ticks = mfp.tim_dt_c; 46 /* The probability of underflow is less than 2% */ 47 if (ticks > INT_TICKS - INT_TICKS / 50) 48 /* Check for pending timer interrupt */ 49 if (mfp.int_pn_b & (1 << 5)) 50 offset = TICK_SIZE; 51 52 ticks = INT_TICKS - ticks; 53 ticks = ticks * 10000L / INT_TICKS; 54 55 return ticks + offset; 56 } 57 58 59 static void mste_read(struct MSTE_RTC *val) 60 { 61 #define COPY(v) val->v=(mste_rtc.v & 0xf) 62 do { 63 COPY(sec_ones) ; COPY(sec_tens) ; COPY(min_ones) ; 64 COPY(min_tens) ; COPY(hr_ones) ; COPY(hr_tens) ; 65 COPY(weekday) ; COPY(day_ones) ; COPY(day_tens) ; 66 COPY(mon_ones) ; COPY(mon_tens) ; COPY(year_ones) ; 67 COPY(year_tens) ; 68 /* prevent from reading the clock while it changed */ 69 } while (val->sec_ones != (mste_rtc.sec_ones & 0xf)); 70 #undef COPY 71 } 72 73 static void mste_write(struct MSTE_RTC *val) 74 { 75 #define COPY(v) mste_rtc.v=val->v 76 do { 77 COPY(sec_ones) ; COPY(sec_tens) ; COPY(min_ones) ; 78 COPY(min_tens) ; COPY(hr_ones) ; COPY(hr_tens) ; 79 COPY(weekday) ; COPY(day_ones) ; COPY(day_tens) ; 80 COPY(mon_ones) ; COPY(mon_tens) ; COPY(year_ones) ; 81 COPY(year_tens) ; 82 /* prevent from writing the clock while it changed */ 83 } while (val->sec_ones != (mste_rtc.sec_ones & 0xf)); 84 #undef COPY 85 } 86 87 #define RTC_READ(reg) \ 88 ({ unsigned char __val; \ 89 (void) atari_writeb(reg,&tt_rtc.regsel); \ 90 __val = tt_rtc.data; \ 91 __val; \ 92 }) 93 94 #define RTC_WRITE(reg,val) \ 95 do { \ 96 atari_writeb(reg,&tt_rtc.regsel); \ 97 tt_rtc.data = (val); \ 98 } while(0) 99 100 101 #define HWCLK_POLL_INTERVAL 5 102 103 int atari_mste_hwclk( int op, struct rtc_time *t ) 104 { 105 int hour, year; 106 int hr24=0; 107 struct MSTE_RTC val; 108 109 mste_rtc.mode=(mste_rtc.mode | 1); 110 hr24=mste_rtc.mon_tens & 1; 111 mste_rtc.mode=(mste_rtc.mode & ~1); 112 113 if (op) { 114 /* write: prepare values */ 115 116 val.sec_ones = t->tm_sec % 10; 117 val.sec_tens = t->tm_sec / 10; 118 val.min_ones = t->tm_min % 10; 119 val.min_tens = t->tm_min / 10; 120 hour = t->tm_hour; 121 if (!hr24) { 122 if (hour > 11) 123 hour += 20 - 12; 124 if (hour == 0 || hour == 20) 125 hour += 12; 126 } 127 val.hr_ones = hour % 10; 128 val.hr_tens = hour / 10; 129 val.day_ones = t->tm_mday % 10; 130 val.day_tens = t->tm_mday / 10; 131 val.mon_ones = (t->tm_mon+1) % 10; 132 val.mon_tens = (t->tm_mon+1) / 10; 133 year = t->tm_year - 80; 134 val.year_ones = year % 10; 135 val.year_tens = year / 10; 136 val.weekday = t->tm_wday; 137 mste_write(&val); 138 mste_rtc.mode=(mste_rtc.mode | 1); 139 val.year_ones = (year % 4); /* leap year register */ 140 mste_rtc.mode=(mste_rtc.mode & ~1); 141 } 142 else { 143 mste_read(&val); 144 t->tm_sec = val.sec_ones + val.sec_tens * 10; 145 t->tm_min = val.min_ones + val.min_tens * 10; 146 hour = val.hr_ones + val.hr_tens * 10; 147 if (!hr24) { 148 if (hour == 12 || hour == 12 + 20) 149 hour -= 12; 150 if (hour >= 20) 151 hour += 12 - 20; 152 } 153 t->tm_hour = hour; 154 t->tm_mday = val.day_ones + val.day_tens * 10; 155 t->tm_mon = val.mon_ones + val.mon_tens * 10 - 1; 156 t->tm_year = val.year_ones + val.year_tens * 10 + 80; 157 t->tm_wday = val.weekday; 158 } 159 return 0; 160 } 161 162 int atari_tt_hwclk( int op, struct rtc_time *t ) 163 { 164 int sec=0, min=0, hour=0, day=0, mon=0, year=0, wday=0; 165 unsigned long flags; 166 unsigned char ctrl; 167 int pm = 0; 168 169 ctrl = RTC_READ(RTC_CONTROL); /* control registers are 170 * independent from the UIP */ 171 172 if (op) { 173 /* write: prepare values */ 174 175 sec = t->tm_sec; 176 min = t->tm_min; 177 hour = t->tm_hour; 178 day = t->tm_mday; 179 mon = t->tm_mon + 1; 180 year = t->tm_year - atari_rtc_year_offset; 181 wday = t->tm_wday + (t->tm_wday >= 0); 182 183 if (!(ctrl & RTC_24H)) { 184 if (hour > 11) { 185 pm = 0x80; 186 if (hour != 12) 187 hour -= 12; 188 } 189 else if (hour == 0) 190 hour = 12; 191 } 192 193 if (!(ctrl & RTC_DM_BINARY)) { 194 BIN_TO_BCD(sec); 195 BIN_TO_BCD(min); 196 BIN_TO_BCD(hour); 197 BIN_TO_BCD(day); 198 BIN_TO_BCD(mon); 199 BIN_TO_BCD(year); 200 if (wday >= 0) BIN_TO_BCD(wday); 201 } 202 } 203 204 /* Reading/writing the clock registers is a bit critical due to 205 * the regular update cycle of the RTC. While an update is in 206 * progress, registers 0..9 shouldn't be touched. 207 * The problem is solved like that: If an update is currently in 208 * progress (the UIP bit is set), the process sleeps for a while 209 * (50ms). This really should be enough, since the update cycle 210 * normally needs 2 ms. 211 * If the UIP bit reads as 0, we have at least 244 usecs until the 212 * update starts. This should be enough... But to be sure, 213 * additionally the RTC_SET bit is set to prevent an update cycle. 214 */ 215 216 while( RTC_READ(RTC_FREQ_SELECT) & RTC_UIP ) { 217 if (in_atomic() || irqs_disabled()) 218 mdelay(1); 219 else 220 schedule_timeout_interruptible(HWCLK_POLL_INTERVAL); 221 } 222 223 local_irq_save(flags); 224 RTC_WRITE( RTC_CONTROL, ctrl | RTC_SET ); 225 if (!op) { 226 sec = RTC_READ( RTC_SECONDS ); 227 min = RTC_READ( RTC_MINUTES ); 228 hour = RTC_READ( RTC_HOURS ); 229 day = RTC_READ( RTC_DAY_OF_MONTH ); 230 mon = RTC_READ( RTC_MONTH ); 231 year = RTC_READ( RTC_YEAR ); 232 wday = RTC_READ( RTC_DAY_OF_WEEK ); 233 } 234 else { 235 RTC_WRITE( RTC_SECONDS, sec ); 236 RTC_WRITE( RTC_MINUTES, min ); 237 RTC_WRITE( RTC_HOURS, hour + pm); 238 RTC_WRITE( RTC_DAY_OF_MONTH, day ); 239 RTC_WRITE( RTC_MONTH, mon ); 240 RTC_WRITE( RTC_YEAR, year ); 241 if (wday >= 0) RTC_WRITE( RTC_DAY_OF_WEEK, wday ); 242 } 243 RTC_WRITE( RTC_CONTROL, ctrl & ~RTC_SET ); 244 local_irq_restore(flags); 245 246 if (!op) { 247 /* read: adjust values */ 248 249 if (hour & 0x80) { 250 hour &= ~0x80; 251 pm = 1; 252 } 253 254 if (!(ctrl & RTC_DM_BINARY)) { 255 BCD_TO_BIN(sec); 256 BCD_TO_BIN(min); 257 BCD_TO_BIN(hour); 258 BCD_TO_BIN(day); 259 BCD_TO_BIN(mon); 260 BCD_TO_BIN(year); 261 BCD_TO_BIN(wday); 262 } 263 264 if (!(ctrl & RTC_24H)) { 265 if (!pm && hour == 12) 266 hour = 0; 267 else if (pm && hour != 12) 268 hour += 12; 269 } 270 271 t->tm_sec = sec; 272 t->tm_min = min; 273 t->tm_hour = hour; 274 t->tm_mday = day; 275 t->tm_mon = mon - 1; 276 t->tm_year = year + atari_rtc_year_offset; 277 t->tm_wday = wday - 1; 278 } 279 280 return( 0 ); 281 } 282 283 284 int atari_mste_set_clock_mmss (unsigned long nowtime) 285 { 286 short real_seconds = nowtime % 60, real_minutes = (nowtime / 60) % 60; 287 struct MSTE_RTC val; 288 unsigned char rtc_minutes; 289 290 mste_read(&val); 291 rtc_minutes= val.min_ones + val.min_tens * 10; 292 if ((rtc_minutes < real_minutes 293 ? real_minutes - rtc_minutes 294 : rtc_minutes - real_minutes) < 30) 295 { 296 val.sec_ones = real_seconds % 10; 297 val.sec_tens = real_seconds / 10; 298 val.min_ones = real_minutes % 10; 299 val.min_tens = real_minutes / 10; 300 mste_write(&val); 301 } 302 else 303 return -1; 304 return 0; 305 } 306 307 int atari_tt_set_clock_mmss (unsigned long nowtime) 308 { 309 int retval = 0; 310 short real_seconds = nowtime % 60, real_minutes = (nowtime / 60) % 60; 311 unsigned char save_control, save_freq_select, rtc_minutes; 312 313 save_control = RTC_READ (RTC_CONTROL); /* tell the clock it's being set */ 314 RTC_WRITE (RTC_CONTROL, save_control | RTC_SET); 315 316 save_freq_select = RTC_READ (RTC_FREQ_SELECT); /* stop and reset prescaler */ 317 RTC_WRITE (RTC_FREQ_SELECT, save_freq_select | RTC_DIV_RESET2); 318 319 rtc_minutes = RTC_READ (RTC_MINUTES); 320 if (!(save_control & RTC_DM_BINARY)) 321 BCD_TO_BIN (rtc_minutes); 322 323 /* Since we're only adjusting minutes and seconds, don't interfere 324 with hour overflow. This avoids messing with unknown time zones 325 but requires your RTC not to be off by more than 30 minutes. */ 326 if ((rtc_minutes < real_minutes 327 ? real_minutes - rtc_minutes 328 : rtc_minutes - real_minutes) < 30) 329 { 330 if (!(save_control & RTC_DM_BINARY)) 331 { 332 BIN_TO_BCD (real_seconds); 333 BIN_TO_BCD (real_minutes); 334 } 335 RTC_WRITE (RTC_SECONDS, real_seconds); 336 RTC_WRITE (RTC_MINUTES, real_minutes); 337 } 338 else 339 retval = -1; 340 341 RTC_WRITE (RTC_FREQ_SELECT, save_freq_select); 342 RTC_WRITE (RTC_CONTROL, save_control); 343 return retval; 344 } 345 346 /* 347 * Local variables: 348 * c-indent-level: 4 349 * tab-width: 8 350 * End: 351 */ 352