libogc/timesupp.c

   1 #include <_ansi.h>
   2 #include <_syslist.h>
   3
   4 #include "asm.h"
   5 #include "processor.h"
   6 #include "lwp.h"
   7 #include "lwp_threadq.h"
   8 #include "timesupp.h"
   9 #include "exi.h"
  10 #include "system.h"
  11 #include "conf.h"
  12
  13 #include <stdio.h>
  14 #include <sys/time.h>
  15
  16 /* time variables */
  17 static u32 exi_wait_inited = 0;
  18 static lwpq_t time_exi_wait;
  19
  20 extern u32 __SYS_GetRTC(u32 *gctime);
  21 extern syssram* __SYS_LockSram();
  22 extern u32 __SYS_UnlockSram(u32 write);
  23
  24
  25
  26 u32 _DEFUN(gettick,(),
  27         _NOARGS)
  28
  29 {
  30         u32 result;
  31         __asm__ __volatile__ (
  32                 "mftb   %0\n"
  33                 : "=r" (result)
  34         );
  35         return result;
  36 }
  37
  38
  39 u64 _DEFUN(gettime,(),
  40                                                   _NOARGS)
  41 {
  42         u32 tmp;
  43         union uulc {
  44                 u64 ull;
  45                 u32 ul[2];
  46         } v;
  47
  48         __asm__ __volatile__(
  49                 "1:     mftbu   %0\n\
  50                     mftb        %1\n\
  51                     mftbu       %2\n\
  52                         cmpw    %0,%2\n\
  53                         bne             1b\n"
  54                 : "=r" (v.ul[0]), "=r" (v.ul[1]), "=&r" (tmp)
  55         );
  56         return v.ull;
  57 }
  58
  59 void _DEFUN(settime,(t),
  60                         u64 t)
  61 {
  62         u32 tmp;
  63         union uulc {
  64                 u64 ull;
  65                 u32 ul[2];
  66         } v;
  67
  68         v.ull = t;
  69         __asm__ __volatile__ (
  70                 "li             %0,0\n\
  71                  mttbl  %0\n\
  72                  mttbu  %1\n\
  73                  mttbl  %2\n"
  74                  : "=&r" (tmp)
  75                  : "r" (v.ul[0]), "r" (v.ul[1])
  76         );
  77 }
  78
  79 u32 diff_sec(u64 start,u64 end)
  80 {
  81         u64 diff;
  82
  83         diff = diff_ticks(start,end);
  84         return ticks_to_secs(diff);
  85 }
  86
  87 u32 diff_msec(u64 start,u64 end)
  88 {
  89         u64 diff;
  90
  91         diff = diff_ticks(start,end);
  92         return ticks_to_millisecs(diff);
  93 }
  94
  95 u32 diff_usec(u64 start,u64 end)
  96 {
  97         u64 diff;
  98
  99         diff = diff_ticks(start,end);
 100         return ticks_to_microsecs(diff);
 101 }
 102
 103 u32 diff_nsec(u64 start,u64 end)
 104 {
 105         u64 diff;
 106
 107         diff = diff_ticks(start,end);
 108         return ticks_to_nanosecs(diff);
 109 }
 110
 111 void __timesystem_init()
 112 {
 113         if(!exi_wait_inited) {
 114                 exi_wait_inited = 1;
 115                 LWP_InitQueue(&time_exi_wait);
 116         }
 117 }
 118
 119 void timespec_subtract(const struct timespec *tp_start,const struct timespec *tp_end,struct timespec *result)
 120 {
 121         struct timespec start_st = *tp_start;
 122         struct timespec *start = &start_st;
 123         u32 nsecpersec = TB_NSPERSEC;
 124
 125         if(tp_end->tv_nsec<start->tv_nsec) {
 126                 int secs = (start->tv_nsec - tp_end->tv_nsec)/nsecpersec+1;
 127                 start->tv_nsec -= nsecpersec * secs;
 128                 start->tv_sec += secs;
 129         }
 130         if((tp_end->tv_nsec - start->tv_nsec)>nsecpersec) {
 131                 int secs = (start->tv_nsec - tp_end->tv_nsec)/nsecpersec;
 132                 start->tv_nsec += nsecpersec * secs;
 133                 start->tv_sec -= secs;
 134         }
 135
 136         result->tv_sec = (tp_end->tv_sec - start->tv_sec);
 137         result->tv_nsec = (tp_end->tv_nsec - start->tv_nsec);
 138 }
 139
 140 unsigned long long timespec_to_ticks(const struct timespec *tp)
 141 {
 142         return __lwp_wd_calc_ticks(tp);
 143 }
 144
 145 int clock_gettime(struct timespec *tp)
 146 {
 147         u32 gctime;
 148 #if defined(HW_RVL)
 149         u32 wii_bias = 0;
 150 #endif
 151
 152         if(!tp) return -1;
 153
 154         if(!__SYS_GetRTC(&gctime)) return -1;
 155
 156 #if defined(HW_DOL)
 157         syssram* sram = __SYS_LockSram();
 158         gctime += sram->counter_bias;
 159         __SYS_UnlockSram(0);
 160 #else
 161         if(CONF_GetCounterBias(&wii_bias)>=0) gctime += wii_bias;
 162 #endif
 163         gctime += 946684800;
 164
 165         tp->tv_sec = gctime;
 166         tp->tv_nsec = ticks_to_nanosecs(gettick());
 167
 168         return 0;
 169 }
 170
 171 // this function spins till timeout is reached
 172 void _DEFUN(udelay,(us),
 173                         unsigned us)
 174 {
 175         unsigned long long start, end;
 176         start = gettime();
 177         while (1)
 178         {
 179                 end = gettime();
 180                 if (diff_usec(start,end) >= us)
 181                         break;
 182         }
 183 }
 184
 185 unsigned int _DEFUN(nanosleep,(tb),
 186            struct timespec *tb)
 187 {
 188         u64 timeout;
 189
 190         __lwp_thread_dispatchdisable();
 191
 192         timeout = __lwp_wd_calc_ticks(tb);
 193         __lwp_thread_setstate(_thr_executing,LWP_STATES_DELAYING|LWP_STATES_INTERRUPTIBLE_BY_SIGNAL);
 194         __lwp_wd_initialize(&_thr_executing->timer,__lwp_thread_delayended,_thr_executing->object.id,_thr_executing);
 195         __lwp_wd_insert_ticks(&_thr_executing->timer,timeout);
 196
 197         __lwp_thread_dispatchenable();
 198         return TB_SUCCESSFUL;
 199 }
 200
 201 static u32 __getrtc(u32 *gctime)
 202 {
 203         u32 ret;
 204         u32 cmd;
 205         u32 time;
 206
 207         if(EXI_Select(EXI_CHANNEL_0,EXI_DEVICE_1,EXI_SPEED8MHZ)==0) {
 208                 return 0;
 209         }
 210
 211         ret = 0;
 212         time = 0;
 213         cmd = 0x20000000;
 214         if(EXI_Imm(EXI_CHANNEL_0,&cmd,4,EXI_WRITE,NULL)==0) ret |= 0x01;
 215         if(EXI_Sync(EXI_CHANNEL_0)==0) ret |= 0x02;
 216         if(EXI_Imm(EXI_CHANNEL_0,&time,4,EXI_READ,NULL)==0) ret |= 0x04;
 217         if(EXI_Sync(EXI_CHANNEL_0)==0) ret |= 0x08;
 218         if(EXI_Deselect(EXI_CHANNEL_0)==0) ret |= 0x10;
 219
 220         *gctime = time;
 221         if(ret) return 0;
 222
 223         return 1;
 224 }
 225
 226 static s32 __time_exi_unlock(s32 chn,s32 dev)
 227 {
 228         LWP_ThreadBroadcast(time_exi_wait);
 229         return 1;
 230 }
 231
 232 static void __time_exi_wait()
 233 {
 234         u32 ret;
 235
 236         do {
 237                 if((ret=EXI_Lock(EXI_CHANNEL_0,EXI_DEVICE_1,__time_exi_unlock))==1) break;
 238                 LWP_ThreadSleep(time_exi_wait);
 239         }while(ret==0);
 240 }
 241
 242 static u32 __getRTC(u32 *gctime)
 243 {
 244         u32 cnt,ret;
 245         u32 time1,time2;
 246
 247         __time_exi_wait();
 248
 249         cnt = 0;
 250         ret = 0;
 251         while(cnt<16) {
 252                 if(__getrtc(&time1)==0
 253                         || __getrtc(&time2)==0) {
 254                         EXI_Unlock(EXI_CHANNEL_0);
 255                         break;
 256                 }
 257                 if(time1==time2) {
 258                         *gctime = time1;
 259                         EXI_Unlock(EXI_CHANNEL_0);
 260                         return 1;
 261                 }
 262                 cnt++;
 263         }
 264         return 0;
 265 }
 266
 267 time_t _DEFUN(time,(timer),
 268                           time_t *timer)
 269 {
 270         time_t gctime = 0;
 271 #if defined(HW_RVL)
 272         u32 wii_bias = 0;
 273 #endif
 274
 275         if(__getRTC((u32*)&gctime)==0) return (time_t)0;
 276
 277 #if defined(HW_DOL)
 278         syssram* sram = __SYS_LockSram();
 279         gctime += sram->counter_bias;
 280         __SYS_UnlockSram(0);
 281 #else
 282         if(CONF_GetCounterBias(&wii_bias)>=0) gctime += wii_bias;
 283 #endif
 284
 285         gctime += 946684800;
 286
 287         if(timer) *timer = gctime;
 288         return gctime;
 289 }
 290
 291 unsigned int _DEFUN(sleep,(s),
 292                    unsigned int s)
 293 {
 294         struct timespec tb;
 295
 296         tb.tv_sec = s;
 297         tb.tv_nsec = 0;
 298         return nanosleep(&tb);
 299 }
 300
 301 unsigned int _DEFUN(usleep,(us),
 302            unsigned int us)
 303 {
 304         u32 sec,rem;
 305         struct timespec tb;
 306
 307         sec = us/TB_USPERSEC;
 308         rem = us - (sec*TB_USPERSEC);
 309
 310         tb.tv_sec = sec;
 311         tb.tv_nsec = rem*TB_NSPERUS;
 312         return nanosleep(&tb);
 313 }
 314
 315 clock_t clock(void) {
 316         return -1;
 317 }
 318
 319 int __libogc_gettod_r(struct _reent *ptr, struct timeval *tp, struct timezone *tz) {
 320
 321         if (tp != NULL) {
 322                 tp->tv_sec = time(NULL);
 323                 tp->tv_usec = tick_microsecs(gettick());
 324         }
 325         if (tz != NULL) {
 326                 tz->tz_minuteswest = 0;
 327                 tz->tz_dsttime = 0;
 328
 329         }
 330         return 0;
 331 }
 332