← Back to branch summary

~ubuntu-branches/ubuntu/utopic/linux-ti-omap/utopic

« back to all changes in this revision

Viewing changes to kernel/timeconst.pl

  • Committer: Bazaar Package Importer
  • Author(s): Amit Kucheria, Amit Kucheria
  • Date: 2010-03-10 02:28:15 UTC
  • Revision ID: james.westby@ubuntu.com-20100310022815-7sd3gwvn5kenaq33
Tags: 2.6.33-500.1
[ Amit Kucheria ]

* Initial release of a 2.6.33-based OMAP kernel
* UBUNTU: [Upstream] Fix omap 1-wire driver compilation
* UBUNTU: ubuntu: AppArmor -- update to mainline 2010-03-04

Show diffs side-by-side

added added

removed removed

Lines of Context:
kernel/timeconst.pl
 
1
#!/usr/bin/perl
 
2
# -----------------------------------------------------------------------
 
3
#
 
4
#   Copyright 2007-2008 rPath, Inc. - All Rights Reserved
 
5
#
 
6
#   This file is part of the Linux kernel, and is made available under
 
7
#   the terms of the GNU General Public License version 2 or (at your
 
8
#   option) any later version; incorporated herein by reference.
 
9
#
 
10
# -----------------------------------------------------------------------
 
11
#
 
12
 
 
13
#
 
14
# Usage: timeconst.pl HZ > timeconst.h
 
15
#
 
16
 
 
17
# Precomputed values for systems without Math::BigInt
 
18
# Generated by:
 
19
# timeconst.pl --can 24 32 48 64 100 122 128 200 250 256 300 512 1000 1024 1200
 
20
%canned_values = (
 
21
        24 => [
 
22
                '0xa6aaaaab','0x2aaaaaa',26,
 
23
                125,3,
 
24
                '0xc49ba5e4','0x1fbe76c8b4',37,
 
25
                3,125,
 
26
                '0xa2c2aaab','0xaaaa',16,
 
27
                125000,3,
 
28
                '0xc9539b89','0x7fffbce4217d',47,
 
29
                3,125000,
 
30
        ], 32 => [
 
31
                '0xfa000000','0x6000000',27,
 
32
                125,4,
 
33
                '0x83126e98','0xfdf3b645a',36,
 
34
                4,125,
 
35
                '0xf4240000','0x0',17,
 
36
                31250,1,
 
37
                '0x8637bd06','0x3fff79c842fa',46,
 
38
                1,31250,
 
39
        ], 48 => [
 
40
                '0xa6aaaaab','0x6aaaaaa',27,
 
41
                125,6,
 
42
                '0xc49ba5e4','0xfdf3b645a',36,
 
43
                6,125,
 
44
                '0xa2c2aaab','0x15555',17,
 
45
                62500,3,
 
46
                '0xc9539b89','0x3fffbce4217d',46,
 
47
                3,62500,
 
48
        ], 64 => [
 
49
                '0xfa000000','0xe000000',28,
 
50
                125,8,
 
51
                '0x83126e98','0x7ef9db22d',35,
 
52
                8,125,
 
53
                '0xf4240000','0x0',18,
 
54
                15625,1,
 
55
                '0x8637bd06','0x1fff79c842fa',45,
 
56
                1,15625,
 
57
        ], 100 => [
 
58
                '0xa0000000','0x0',28,
 
59
                10,1,
 
60
                '0xcccccccd','0x733333333',35,
 
61
                1,10,
 
62
                '0x9c400000','0x0',18,
 
63
                10000,1,
 
64
                '0xd1b71759','0x1fff2e48e8a7',45,
 
65
                1,10000,
 
66
        ], 122 => [
 
67
                '0x8325c53f','0xfbcda3a',28,
 
68
                500,61,
 
69
                '0xf9db22d1','0x7fbe76c8b',35,
 
70
                61,500,
 
71
                '0x8012e2a0','0x3ef36',18,
 
72
                500000,61,
 
73
                '0xffda4053','0x1ffffbce4217',45,
 
74
                61,500000,
 
75
        ], 128 => [
 
76
                '0xfa000000','0x1e000000',29,
 
77
                125,16,
 
78
                '0x83126e98','0x3f7ced916',34,
 
79
                16,125,
 
80
                '0xf4240000','0x40000',19,
 
81
                15625,2,
 
82
                '0x8637bd06','0xfffbce4217d',44,
 
83
                2,15625,
 
84
        ], 200 => [
 
85
                '0xa0000000','0x0',29,
 
86
                5,1,
 
87
                '0xcccccccd','0x333333333',34,
 
88
                1,5,
 
89
                '0x9c400000','0x0',19,
 
90
                5000,1,
 
91
                '0xd1b71759','0xfff2e48e8a7',44,
 
92
                1,5000,
 
93
        ], 250 => [
 
94
                '0x80000000','0x0',29,
 
95
                4,1,
 
96
                '0x80000000','0x180000000',33,
 
97
                1,4,
 
98
                '0xfa000000','0x0',20,
 
99
                4000,1,
 
100
                '0x83126e98','0x7ff7ced9168',43,
 
101
                1,4000,
 
102
        ], 256 => [
 
103
                '0xfa000000','0x3e000000',30,
 
104
                125,32,
 
105
                '0x83126e98','0x1fbe76c8b',33,
 
106
                32,125,
 
107
                '0xf4240000','0xc0000',20,
 
108
                15625,4,
 
109
                '0x8637bd06','0x7ffde7210be',43,
 
110
                4,15625,
 
111
        ], 300 => [
 
112
                '0xd5555556','0x2aaaaaaa',30,
 
113
                10,3,
 
114
                '0x9999999a','0x1cccccccc',33,
 
115
                3,10,
 
116
                '0xd0555556','0xaaaaa',20,
 
117
                10000,3,
 
118
                '0x9d495183','0x7ffcb923a29',43,
 
119
                3,10000,
 
120
        ], 512 => [
 
121
                '0xfa000000','0x7e000000',31,
 
122
                125,64,
 
123
                '0x83126e98','0xfdf3b645',32,
 
124
                64,125,
 
125
                '0xf4240000','0x1c0000',21,
 
126
                15625,8,
 
127
                '0x8637bd06','0x3ffef39085f',42,
 
128
                8,15625,
 
129
        ], 1000 => [
 
130
                '0x80000000','0x0',31,
 
131
                1,1,
 
132
                '0x80000000','0x0',31,
 
133
                1,1,
 
134
                '0xfa000000','0x0',22,
 
135
                1000,1,
 
136
                '0x83126e98','0x1ff7ced9168',41,
 
137
                1,1000,
 
138
        ], 1024 => [
 
139
                '0xfa000000','0xfe000000',32,
 
140
                125,128,
 
141
                '0x83126e98','0x7ef9db22',31,
 
142
                128,125,
 
143
                '0xf4240000','0x3c0000',22,
 
144
                15625,16,
 
145
                '0x8637bd06','0x1fff79c842f',41,
 
146
                16,15625,
 
147
        ], 1200 => [
 
148
                '0xd5555556','0xd5555555',32,
 
149
                5,6,
 
150
                '0x9999999a','0x66666666',31,
 
151
                6,5,
 
152
                '0xd0555556','0x2aaaaa',22,
 
153
                2500,3,
 
154
                '0x9d495183','0x1ffcb923a29',41,
 
155
                3,2500,
 
156
        ]
 
157
);
 
158
 
 
159
$has_bigint = eval 'use Math::BigInt qw(bgcd); 1;';
 
160
 
 
161
sub bint($)
 
162
{
 
163
        my($x) = @_;
 
164
        return Math::BigInt->new($x);
 
165
}
 
166
 
 
167
#
 
168
# Constants for division by reciprocal multiplication.
 
169
# (bits, numerator, denominator)
 
170
#
 
171
sub fmul($$$)
 
172
{
 
173
        my ($b,$n,$d) = @_;
 
174
 
 
175
        $n = bint($n);
 
176
        $d = bint($d);
 
177
 
 
178
        return scalar (($n << $b)+$d-bint(1))/$d;
 
179
}
 
180
 
 
181
sub fadj($$$)
 
182
{
 
183
        my($b,$n,$d) = @_;
 
184
 
 
185
        $n = bint($n);
 
186
        $d = bint($d);
 
187
 
 
188
        $d = $d/bgcd($n, $d);
 
189
        return scalar (($d-bint(1)) << $b)/$d;
 
190
}
 
191
 
 
192
sub fmuls($$$) {
 
193
        my($b,$n,$d) = @_;
 
194
        my($s,$m);
 
195
        my($thres) = bint(1) << ($b-1);
 
196
 
 
197
        $n = bint($n);
 
198
        $d = bint($d);
 
199
 
 
200
        for ($s = 0; 1; $s++) {
 
201
                $m = fmul($s,$n,$d);
 
202
                return $s if ($m >= $thres);
 
203
        }
 
204
        return 0;
 
205
}
 
206
 
 
207
# Generate a hex value if the result fits in 64 bits;
 
208
# otherwise skip.
 
209
sub bignum_hex($) {
 
210
        my($x) = @_;
 
211
        my $s = $x->as_hex();
 
212
 
 
213
        return (length($s) > 18) ? undef : $s;
 
214
}
 
215
 
 
216
# Provides mul, adj, and shr factors for a specific
 
217
# (bit, time, hz) combination
 
218
sub muladj($$$) {
 
219
        my($b, $t, $hz) = @_;
 
220
        my $s = fmuls($b, $t, $hz);
 
221
        my $m = fmul($s, $t, $hz);
 
222
        my $a = fadj($s, $t, $hz);
 
223
        return (bignum_hex($m), bignum_hex($a), $s);
 
224
}
 
225
 
 
226
# Provides numerator, denominator values
 
227
sub numden($$) {
 
228
        my($n, $d) = @_;
 
229
        my $g = bgcd($n, $d);
 
230
        return ($n/$g, $d/$g);
 
231
}
 
232
 
 
233
# All values for a specific (time, hz) combo
 
234
sub conversions($$) {
 
235
        my ($t, $hz) = @_;
 
236
        my @val = ();
 
237
 
 
238
        # HZ_TO_xx
 
239
        push(@val, muladj(32, $t, $hz));
 
240
        push(@val, numden($t, $hz));
 
241
 
 
242
        # xx_TO_HZ
 
243
        push(@val, muladj(32, $hz, $t));
 
244
        push(@val, numden($hz, $t));
 
245
 
 
246
        return @val;
 
247
}
 
248
 
 
249
sub compute_values($) {
 
250
        my($hz) = @_;
 
251
        my @val = ();
 
252
        my $s, $m, $a, $g;
 
253
 
 
254
        if (!$has_bigint) {
 
255
                die "$0: HZ == $hz not canned and ".
 
256
                    "Math::BigInt not available\n";
 
257
        }
 
258
 
 
259
        # MSEC conversions
 
260
        push(@val, conversions(1000, $hz));
 
261
 
 
262
        # USEC conversions
 
263
        push(@val, conversions(1000000, $hz));
 
264
 
 
265
        return @val;
 
266
}
 
267
 
 
268
sub outputval($$)
 
269
{
 
270
        my($name, $val) = @_;
 
271
        my $csuf;
 
272
 
 
273
        if (defined($val)) {
 
274
            if ($name !~ /SHR/) {
 
275
                $val = "U64_C($val)";
 
276
            }
 
277
            printf "#define %-23s %s\n", $name.$csuf, $val.$csuf;
 
278
        }
 
279
}
 
280
 
 
281
sub output($@)
 
282
{
 
283
        my($hz, @val) = @_;
 
284
        my $pfx, $bit, $suf, $s, $m, $a;
 
285
 
 
286
        print "/* Automatically generated by kernel/timeconst.pl */\n";
 
287
        print "/* Conversion constants for HZ == $hz */\n";
 
288
        print "\n";
 
289
        print "#ifndef KERNEL_TIMECONST_H\n";
 
290
        print "#define KERNEL_TIMECONST_H\n";
 
291
        print "\n";
 
292
 
 
293
        print "#include <linux/param.h>\n";
 
294
        print "#include <linux/types.h>\n";
 
295
 
 
296
        print "\n";
 
297
        print "#if HZ != $hz\n";
 
298
        print "#error \"kernel/timeconst.h has the wrong HZ value!\"\n";
 
299
        print "#endif\n";
 
300
        print "\n";
 
301
 
 
302
        foreach $pfx ('HZ_TO_MSEC','MSEC_TO_HZ',
 
303
                      'HZ_TO_USEC','USEC_TO_HZ') {
 
304
                foreach $bit (32) {
 
305
                        foreach $suf ('MUL', 'ADJ', 'SHR') {
 
306
                                outputval("${pfx}_$suf$bit", shift(@val));
 
307
                        }
 
308
                }
 
309
                foreach $suf ('NUM', 'DEN') {
 
310
                        outputval("${pfx}_$suf", shift(@val));
 
311
                }
 
312
        }
 
313
 
 
314
        print "\n";
 
315
        print "#endif /* KERNEL_TIMECONST_H */\n";
 
316
}
 
317
 
 
318
# Pretty-print Perl values
 
319
sub perlvals(@) {
 
320
        my $v;
 
321
        my @l = ();
 
322
 
 
323
        foreach $v (@_) {
 
324
                if (!defined($v)) {
 
325
                        push(@l, 'undef');
 
326
                } elsif ($v =~ /^0x/) {
 
327
                        push(@l, "\'".$v."\'");
 
328
                } else {
 
329
                        push(@l, $v.'');
 
330
                }
 
331
        }
 
332
        return join(',', @l);
 
333
}
 
334
 
 
335
($hz) = @ARGV;
 
336
 
 
337
# Use this to generate the %canned_values structure
 
338
if ($hz eq '--can') {
 
339
        shift(@ARGV);
 
340
        @hzlist = sort {$a <=> $b} (@ARGV);
 
341
 
 
342
        print "# Precomputed values for systems without Math::BigInt\n";
 
343
        print "# Generated by:\n";
 
344
        print "# timeconst.pl --can ", join(' ', @hzlist), "\n";
 
345
        print "\%canned_values = (\n";
 
346
        my $pf = "\t";
 
347
        foreach $hz (@hzlist) {
 
348
                my @values = compute_values($hz);
 
349
                print "$pf$hz => [\n";
 
350
                while (scalar(@values)) {
 
351
                        my $bit;
 
352
                        foreach $bit (32) {
 
353
                                my $m = shift(@values);
 
354
                                my $a = shift(@values);
 
355
                                my $s = shift(@values);
 
356
                                print "\t\t", perlvals($m,$a,$s), ",\n";
 
357
                        }
 
358
                        my $n = shift(@values);
 
359
                        my $d = shift(@values);
 
360
                        print "\t\t", perlvals($n,$d), ",\n";
 
361
                }
 
362
                print "\t]";
 
363
                $pf = ', ';
 
364
        }
 
365
        print "\n);\n";
 
366
} else {
 
367
        $hz += 0;                       # Force to number
 
368
        if ($hz < 1) {
 
369
                die "Usage: $0 HZ\n";
 
370
        }
 
371
 
 
372
        @val = @{$canned_values{$hz}};
 
373
        if (!defined(@val)) {
 
374
                @val = compute_values($hz);
 
375
        }
 
376
        output($hz, @val);
 
377
}
 
378
exit 0;