Rev 3297 | Go to most recent revision | Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
3031 | serge | 1 | #include |
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 |