linux/JackLinuxTime.c

   1 /*
   2 Copyright (C) 2001-2003 Paul Davis
   3 Copyright (C) 2005 Jussi Laako
   4 Copyright (C) 2004-2008 Grame
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU Lesser General Public License as published by
   8 the Free Software Foundation; either version 2.1 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU Lesser General Public License for more details.
  15
  16 You should have received a copy of the GNU Lesser General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  19
  20 */
  21
  22 #include "JackConstants.h"
  23 #include "JackTime.h"
  24 #include "JackTypes.h"
  25 #include "JackError.h"
  26 #include "cycles.h"
  27
  28 #include <stdint.h>
  29 #include <stdio.h>
  30 #include <sys/mman.h>
  31 #include <sys/time.h>
  32 #include <sys/types.h>
  33 #include <sys/stat.h>
  34 #include <fcntl.h>
  35 #include <errno.h>
  36 #include <string.h>
  37 #include <unistd.h>
  38 #include <stdlib.h>
  39
  40 static jack_time_t __jack_cpu_mhz = 0;
  41 jack_time_t (*_jack_get_microseconds)(void) = 0;
  42
  43 #if defined(__gnu_linux__) && (defined(__i386__) || defined(__x86_64__))
  44 #define HPET_SUPPORT
  45 #define HPET_MMAP_SIZE                  1024
  46 #define HPET_CAPS                       0x000
  47 #define HPET_PERIOD                     0x004
  48 #define HPET_COUNTER                    0x0f0
  49 #define HPET_CAPS_COUNTER_64BIT         (1 << 13)
  50 #if defined(__x86_64__)
  51 typedef uint64_t hpet_counter_t;
  52 #else
  53 typedef uint32_t hpet_counter_t;
  54 #endif
  55 static int hpet_fd;
  56 static unsigned char *hpet_ptr;
  57 static uint32_t hpet_period; /* period length in femto secs */
  58 static uint64_t hpet_offset = 0;
  59 static uint64_t hpet_wrap;
  60 static hpet_counter_t hpet_previous = 0;
  61 #endif /* defined(__gnu_linux__) && (__i386__ || __x86_64__) */
  62
  63 #ifdef HPET_SUPPORT
  64
  65 static int jack_hpet_init ()
  66 {
  67         uint32_t hpet_caps;
  68
  69         hpet_fd = open("/dev/hpet", O_RDONLY);
  70         if (hpet_fd < 0) {
  71                 jack_error ("This system has no accessible HPET device (%s)", strerror (errno));
  72                 return -1;
  73         }
  74
  75         hpet_ptr = (unsigned char *) mmap(NULL, HPET_MMAP_SIZE,
  76                                           PROT_READ, MAP_SHARED, hpet_fd, 0);
  77         if (hpet_ptr == MAP_FAILED) {
  78                 jack_error ("This system has no mappable HPET device (%s)", strerror (errno));
  79                 close (hpet_fd);
  80                 return -1;
  81         }
  82
  83         /* this assumes period to be constant. if needed,
  84            it can be moved to the clock access function
  85         */
  86         hpet_period = *((uint32_t *) (hpet_ptr + HPET_PERIOD));
  87         hpet_caps = *((uint32_t *) (hpet_ptr + HPET_CAPS));
  88         hpet_wrap = ((hpet_caps & HPET_CAPS_COUNTER_64BIT) &&
  89                 (sizeof(hpet_counter_t) == sizeof(uint64_t))) ?
  90                 0 : ((uint64_t) 1 << 32);
  91
  92         return 0;
  93 }
  94
  95 static jack_time_t jack_get_microseconds_from_hpet (void)
  96 {
  97         hpet_counter_t hpet_counter;
  98         long double hpet_time;
  99
 100         hpet_counter = *((hpet_counter_t *) (hpet_ptr + HPET_COUNTER));
 101         if (hpet_counter < hpet_previous)
 102                 hpet_offset += hpet_wrap;
 103         hpet_previous = hpet_counter;
 104         hpet_time = (long double) (hpet_offset + hpet_counter) *
 105                 (long double) hpet_period * (long double) 1e-9;
 106         return ((jack_time_t) (hpet_time + 0.5));
 107 }
 108
 109 #else
 110
 111 static int jack_hpet_init ()
 112 {
 113         jack_error ("This version of JACK or this computer does not have HPET support.\n"
 114                     "Please choose a different clock source.");
 115         return -1;
 116 }
 117
 118 static jack_time_t jack_get_microseconds_from_hpet (void)
 119 {
 120         /* never called */
 121         return 0;
 122 }
 123
 124 #endif /* HPET_SUPPORT */
 125
 126 static jack_time_t jack_get_microseconds_from_cycles (void) {
 127         return get_cycles() / __jack_cpu_mhz;
 128 }
 129
 130 /*
 131  * This is another kludge.  It looks CPU-dependent, but actually it
 132  * reflects the lack of standards for the Linux kernel formatting of
 133  * /proc/cpuinfo.
 134  */
 135
 136 static jack_time_t jack_get_mhz (void)
 137 {
 138         FILE *f = fopen("/proc/cpuinfo", "r");
 139         if (f == 0)
 140         {
 141                 perror("can't open /proc/cpuinfo\n");
 142                 exit(1);
 143         }
 144
 145         for ( ; ; )
 146         {
 147                 jack_time_t mhz;
 148                 int ret;
 149                 char buf[1000];
 150
 151                 if (fgets(buf, sizeof(buf), f) == NULL) {
 152                         jack_error ("FATAL: cannot locate cpu MHz in "
 153                                     "/proc/cpuinfo\n");
 154                         exit(1);
 155                 }
 156
 157 #if defined(__powerpc__)
 158                 ret = sscanf(buf, "clock\t: %" SCNu64 "MHz", &mhz);
 159 #elif defined( __i386__ ) || defined (__hppa__)  || defined (__ia64__) || \
 160       defined(__x86_64__)
 161                 ret = sscanf(buf, "cpu MHz         : %" SCNu64, &mhz);
 162 #elif defined( __sparc__ )
 163                 ret = sscanf(buf, "Cpu0Bogo        : %" SCNu64, &mhz);
 164 #elif defined( __mc68000__ )
 165                 ret = sscanf(buf, "Clocking:       %" SCNu64, &mhz);
 166 #elif defined( __s390__  )
 167                 ret = sscanf(buf, "bogomips per cpu: %" SCNu64, &mhz);
 168 #else /* MIPS, ARM, alpha */
 169                 ret = sscanf(buf, "BogoMIPS        : %" SCNu64, &mhz);
 170 #endif
 171
 172                 if (ret == 1)
 173                 {
 174                         fclose(f);
 175                         return (jack_time_t)mhz;
 176                 }
 177         }
 178 }
 179
 180 #define HAVE_CLOCK_GETTIME 1
 181
 182 #ifndef HAVE_CLOCK_GETTIME
 183
 184 static jack_time_t jack_get_microseconds_from_system (void)
 185 {
 186         jack_time_t jackTime;
 187         struct timeval tv;
 188
 189         gettimeofday (&tv, NULL);
 190         jackTime = (jack_time_t) tv.tv_sec * 1000000 + (jack_time_t) tv.tv_usec;
 191         return jackTime;
 192 }
 193
 194 #else
 195
 196 static jack_time_t jack_get_microseconds_from_system (void)
 197 {
 198         jack_time_t jackTime;
 199         struct timespec time;
 200
 201         clock_gettime(CLOCK_MONOTONIC, &time);
 202         jackTime = (jack_time_t) time.tv_sec * 1e6 +
 203                 (jack_time_t) time.tv_nsec / 1e3;
 204         return jackTime;
 205 }
 206
 207 #endif /* HAVE_CLOCK_GETTIME */
 208
 209
 210 SERVER_EXPORT void JackSleep(long usec)
 211 {
 212         usleep(usec);
 213 }
 214
 215 SERVER_EXPORT void InitTime()
 216 {
 217         __jack_cpu_mhz = jack_get_mhz ();
 218 }
 219
 220 SERVER_EXPORT void SetClockSource(jack_timer_type_t source)
 221 {
 222         jack_log("Clock source : %s", ClockSourceName(source));
 223
 224         switch (source)
 225         {
 226         case JACK_TIMER_CYCLE_COUNTER:
 227                 _jack_get_microseconds = jack_get_microseconds_from_cycles;
 228                 break;
 229
 230         case JACK_TIMER_HPET:
 231                 if (jack_hpet_init () == 0) {
 232                         _jack_get_microseconds = jack_get_microseconds_from_hpet;
 233                 } else {
 234                         _jack_get_microseconds = jack_get_microseconds_from_system;
 235                 }
 236                 break;
 237
 238         case JACK_TIMER_SYSTEM_CLOCK:
 239         default:
 240                 _jack_get_microseconds = jack_get_microseconds_from_system;
 241                 break;
 242         }
 243 }
 244
 245 SERVER_EXPORT const char* ClockSourceName(jack_timer_type_t source)
 246 {
 247         switch (source) {
 248         case JACK_TIMER_CYCLE_COUNTER:
 249                 return "cycle counter";
 250         case JACK_TIMER_HPET:
 251                 return "hpet";
 252         case JACK_TIMER_SYSTEM_CLOCK:
 253 #ifdef HAVE_CLOCK_GETTIME
 254                 return "system clock via clock_gettime";
 255 #else
 256                 return "system clock via gettimeofday";
 257 #endif
 258         }
 259
 260         /* what is wrong with gcc ? */
 261         return "unknown";
 262 }
 263
 264 SERVER_EXPORT jack_time_t GetMicroSeconds()
 265 {
 266         return _jack_get_microseconds();
 267 }