arch/m68k/atari/time.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
mfp_timer_c_handler
atari_sched_init
atari_read_clk
mste_read
mste_write
atari_mste_hwclk
atari_tt_hwclk
   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  */
/* [<][>][^][v][top][bottom][index][help] */
root/arch/m68k/atari/time.c

DEFINITIONS
