Subversion Repositories Kolibri OS

Rev

Rev 3297 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. #include <jiffies.h>
  2.  
  3.  
  4.  
  5. #define HZ_TO_MSEC_MUL32 0xA0000000
  6. #define HZ_TO_MSEC_ADJ32 0x0
  7. #define HZ_TO_MSEC_SHR32 28
  8. #define HZ_TO_MSEC_MUL64 0xA000000000000000
  9. #define HZ_TO_MSEC_ADJ64 0x0
  10. #define HZ_TO_MSEC_SHR64 60
  11. #define MSEC_TO_HZ_MUL32 0xCCCCCCCD
  12. #define MSEC_TO_HZ_ADJ32 0x733333333
  13. #define MSEC_TO_HZ_SHR32 35
  14. #define MSEC_TO_HZ_MUL64 0xCCCCCCCCCCCCCCCD
  15. #define MSEC_TO_HZ_ADJ64 0x73333333333333333
  16. #define MSEC_TO_HZ_SHR64 67
  17. #define HZ_TO_MSEC_NUM 10
  18. #define HZ_TO_MSEC_DEN 1
  19. #define MSEC_TO_HZ_NUM 1
  20. #define MSEC_TO_HZ_DEN 10
  21.  
  22. #define HZ_TO_USEC_MUL32 0x9C400000
  23. #define HZ_TO_USEC_ADJ32 0x0
  24. #define HZ_TO_USEC_SHR32 18
  25. #define HZ_TO_USEC_MUL64 0x9C40000000000000
  26. #define HZ_TO_USEC_ADJ64 0x0
  27. #define HZ_TO_USEC_SHR64 50
  28. #define USEC_TO_HZ_MUL32 0xD1B71759
  29. #define USEC_TO_HZ_ADJ32 0x1FFF2E48E8A7
  30. #define USEC_TO_HZ_SHR32 45
  31. #define USEC_TO_HZ_MUL64 0xD1B71758E219652C
  32. #define USEC_TO_HZ_ADJ64 0x1FFF2E48E8A71DE69AD4
  33. #define USEC_TO_HZ_SHR64 77
  34. #define HZ_TO_USEC_NUM 10000
  35. #define HZ_TO_USEC_DEN 1
  36. #define USEC_TO_HZ_NUM 1
  37. #define USEC_TO_HZ_DEN 10000
  38.  
  39.  
  40. #define MSEC_PER_SEC    1000L
  41. #define USEC_PER_MSEC   1000L
  42. #define NSEC_PER_USEC   1000L
  43. #define NSEC_PER_MSEC   1000000L
  44. #define USEC_PER_SEC    1000000L
  45. #define NSEC_PER_SEC    1000000000L
  46. #define FSEC_PER_SEC    1000000000000000LL
  47.  
  48.  
  49. unsigned int jiffies_to_msecs(const unsigned long j)
  50. {
  51. #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
  52.         return (MSEC_PER_SEC / HZ) * j;
  53. #elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
  54.         return (j + (HZ / MSEC_PER_SEC) - 1)/(HZ / MSEC_PER_SEC);
  55. #else
  56. # if BITS_PER_LONG == 32
  57.         return (HZ_TO_MSEC_MUL32 * j) >> HZ_TO_MSEC_SHR32;
  58. # else
  59.         return (j * HZ_TO_MSEC_NUM) / HZ_TO_MSEC_DEN;
  60. # endif
  61. #endif
  62. }
  63.  
  64. unsigned int jiffies_to_usecs(const unsigned long j)
  65. {
  66. #if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)
  67.         return (USEC_PER_SEC / HZ) * j;
  68. #elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)
  69.         return (j + (HZ / USEC_PER_SEC) - 1)/(HZ / USEC_PER_SEC);
  70. #else
  71. # if BITS_PER_LONG == 32
  72.         return (HZ_TO_USEC_MUL32 * j) >> HZ_TO_USEC_SHR32;
  73. # else
  74.         return (j * HZ_TO_USEC_NUM) / HZ_TO_USEC_DEN;
  75. # endif
  76. #endif
  77. }
  78.  
  79.  
  80. /*
  81.  * When we convert to jiffies then we interpret incoming values
  82.  * the following way:
  83.  *
  84.  * - negative values mean 'infinite timeout' (MAX_JIFFY_OFFSET)
  85.  *
  86.  * - 'too large' values [that would result in larger than
  87.  *   MAX_JIFFY_OFFSET values] mean 'infinite timeout' too.
  88.  *
  89.  * - all other values are converted to jiffies by either multiplying
  90.  *   the input value by a factor or dividing it with a factor
  91.  *
  92.  * We must also be careful about 32-bit overflows.
  93.  */
  94. unsigned long msecs_to_jiffies(const unsigned int m)
  95. {
  96.     /*
  97.      * Negative value, means infinite timeout:
  98.      */
  99.     if ((int)m < 0)
  100.         return MAX_JIFFY_OFFSET;
  101.  
  102. #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
  103.     /*
  104.      * HZ is equal to or smaller than 1000, and 1000 is a nice
  105.      * round multiple of HZ, divide with the factor between them,
  106.      * but round upwards:
  107.      */
  108.     return (m + (MSEC_PER_SEC / HZ) - 1) / (MSEC_PER_SEC / HZ);
  109. #elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
  110.     /*
  111.      * HZ is larger than 1000, and HZ is a nice round multiple of
  112.      * 1000 - simply multiply with the factor between them.
  113.      *
  114.      * But first make sure the multiplication result cannot
  115.      * overflow:
  116.      */
  117.     if (m > jiffies_to_msecs(MAX_JIFFY_OFFSET))
  118.         return MAX_JIFFY_OFFSET;
  119.  
  120.     return m * (HZ / MSEC_PER_SEC);
  121. #else
  122.     /*
  123.      * Generic case - multiply, round and divide. But first
  124.      * check that if we are doing a net multiplication, that
  125.      * we wouldn't overflow:
  126.      */
  127.     if (HZ > MSEC_PER_SEC && m > jiffies_to_msecs(MAX_JIFFY_OFFSET))
  128.         return MAX_JIFFY_OFFSET;
  129.  
  130.     return (MSEC_TO_HZ_MUL32 * m + MSEC_TO_HZ_ADJ32)
  131.         >> MSEC_TO_HZ_SHR32;
  132. #endif
  133. }
  134.  
  135. unsigned long usecs_to_jiffies(const unsigned int u)
  136. {
  137.     if (u > jiffies_to_usecs(MAX_JIFFY_OFFSET))
  138.         return MAX_JIFFY_OFFSET;
  139. #if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)
  140.     return (u + (USEC_PER_SEC / HZ) - 1) / (USEC_PER_SEC / HZ);
  141. #elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)
  142.     return u * (HZ / USEC_PER_SEC);
  143. #else
  144.     return (USEC_TO_HZ_MUL32 * u + USEC_TO_HZ_ADJ32)
  145.         >> USEC_TO_HZ_SHR32;
  146. #endif
  147. }
  148.  
  149.