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