]>
Commit | Line | Data |
---|---|---|
3776801d A |
1 | /* |
2 | * Program for finding M & N values for DPLLs | |
3 | * To be run on Host PC | |
4 | * | |
5 | * (C) Copyright 2010 | |
6 | * Texas Instruments, <www.ti.com> | |
7 | * | |
8 | * Aneesh V <aneesh@ti.com> | |
9 | * | |
10 | * See file CREDITS for list of people who contributed to this | |
11 | * project. | |
12 | * | |
13 | * This program is free software; you can redistribute it and/or | |
14 | * modify it under the terms of the GNU General Public License as | |
15 | * published by the Free Software Foundation; either version 2 of | |
16 | * the License, or (at your option) any later version. | |
17 | * | |
18 | * This program is distributed in the hope that it will be useful, | |
19 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
20 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
21 | * GNU General Public License for more details. | |
22 | * | |
23 | * You should have received a copy of the GNU General Public License | |
24 | * along with this program; if not, write to the Free Software | |
25 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, | |
26 | * MA 02111-1307 USA | |
27 | */ | |
28 | #include <stdlib.h> | |
29 | #include <stdio.h> | |
30 | typedef unsigned int u32; | |
31 | #define MAX_N 127 | |
32 | ||
33 | /* | |
34 | * get_m_n_optimized() - Finds optimal DPLL multiplier(M) and divider(N) | |
35 | * values based on the reference frequency, required output frequency, | |
36 | * maximum tolerance for output frequency etc. | |
37 | * | |
38 | * target_freq_khz - output frequency required in KHz | |
39 | * ref_freq_khz - reference(input) frequency in KHz | |
40 | * m - pointer to computed M value | |
41 | * n - pointer to computed N value | |
42 | * tolerance_khz - tolerance for the output frequency. When the algorithm | |
43 | * succeeds in finding vialble M and N values the corresponding output | |
44 | * frequency will be in the range: | |
45 | * [target_freq_khz - tolerance_khz, target_freq_khz] | |
46 | * | |
47 | * Formula: | |
48 | * Fdpll = (2 * M * Fref) / (N + 1) | |
49 | * | |
50 | * Considerations for lock-time: | |
51 | * - Smaller the N, better lock-time, especially lock-time will be | |
52 | * - For acceptable lock-times: | |
53 | * Fref / (M + 1) >= 1 MHz | |
54 | * | |
55 | * Considerations for power: | |
56 | * - The difference in power for different N values giving the same | |
57 | * output is negligible. So, we optimize for lock-time | |
58 | * | |
59 | * Hard-constraints: | |
60 | * - N can not be greater than 127(7 bit field for representing N) | |
61 | * | |
62 | * Usage: | |
63 | * $ gcc clocks_get_m_n.c | |
64 | * $ ./a.out | |
65 | */ | |
28a181ff | 66 | int get_m_n_optimized(u32 target_freq_khz, u32 ref_freq_khz, u32 *M, u32 *N) |
3776801d | 67 | { |
28a181ff A |
68 | u32 freq = target_freq_khz; |
69 | u32 m_optimal, n_optimal, freq_optimal = 0, freq_old; | |
70 | u32 m, n; | |
71 | n = 1; | |
3776801d | 72 | while (1) { |
28a181ff | 73 | m = target_freq_khz / ref_freq_khz / 2 * n; |
3776801d A |
74 | freq_old = 0; |
75 | while (1) { | |
28a181ff A |
76 | freq = ref_freq_khz * 2 * m / n; |
77 | if (freq > target_freq_khz) { | |
3776801d | 78 | freq = freq_old; |
28a181ff | 79 | m--; |
3776801d A |
80 | break; |
81 | } | |
28a181ff | 82 | m++; |
3776801d A |
83 | freq_old = freq; |
84 | } | |
28a181ff A |
85 | if (freq > freq_optimal) { |
86 | freq_optimal = freq; | |
87 | m_optimal = m; | |
88 | n_optimal = n; | |
89 | } | |
90 | n++; | |
91 | if ((freq_optimal == target_freq_khz) || | |
92 | ((ref_freq_khz / n) < 1000)) { | |
3776801d | 93 | break; |
3776801d A |
94 | } |
95 | } | |
28a181ff A |
96 | n--; |
97 | *M = m_optimal; | |
98 | *N = n_optimal - 1; | |
99 | printf("ref %d m %d n %d target %d locked %d\n", ref_freq_khz, | |
100 | m_optimal, n_optimal - 1, target_freq_khz, freq_optimal); | |
3776801d A |
101 | return 0; |
102 | } | |
103 | ||
104 | void main(void) | |
105 | { | |
106 | u32 m, n; | |
107 | printf("\nMPU - 2000000\n"); | |
28a181ff A |
108 | get_m_n_optimized(2000000, 12000, &m, &n); |
109 | get_m_n_optimized(2000000, 13000, &m, &n); | |
110 | get_m_n_optimized(2000000, 16800, &m, &n); | |
111 | get_m_n_optimized(2000000, 19200, &m, &n); | |
112 | get_m_n_optimized(2000000, 26000, &m, &n); | |
113 | get_m_n_optimized(2000000, 27000, &m, &n); | |
114 | get_m_n_optimized(2000000, 38400, &m, &n); | |
3776801d A |
115 | |
116 | printf("\nMPU - 1200000\n"); | |
28a181ff A |
117 | get_m_n_optimized(1200000, 12000, &m, &n); |
118 | get_m_n_optimized(1200000, 13000, &m, &n); | |
119 | get_m_n_optimized(1200000, 16800, &m, &n); | |
120 | get_m_n_optimized(1200000, 19200, &m, &n); | |
121 | get_m_n_optimized(1200000, 26000, &m, &n); | |
122 | get_m_n_optimized(1200000, 27000, &m, &n); | |
123 | get_m_n_optimized(1200000, 38400, &m, &n); | |
3776801d A |
124 | |
125 | printf("\nMPU - 1584000\n"); | |
28a181ff A |
126 | get_m_n_optimized(1584000, 12000, &m, &n); |
127 | get_m_n_optimized(1584000, 13000, &m, &n); | |
128 | get_m_n_optimized(1584000, 16800, &m, &n); | |
129 | get_m_n_optimized(1584000, 19200, &m, &n); | |
130 | get_m_n_optimized(1584000, 26000, &m, &n); | |
131 | get_m_n_optimized(1584000, 27000, &m, &n); | |
132 | get_m_n_optimized(1584000, 38400, &m, &n); | |
3776801d A |
133 | |
134 | printf("\nCore 1600000\n"); | |
28a181ff A |
135 | get_m_n_optimized(1600000, 12000, &m, &n); |
136 | get_m_n_optimized(1600000, 13000, &m, &n); | |
137 | get_m_n_optimized(1600000, 16800, &m, &n); | |
138 | get_m_n_optimized(1600000, 19200, &m, &n); | |
139 | get_m_n_optimized(1600000, 26000, &m, &n); | |
140 | get_m_n_optimized(1600000, 27000, &m, &n); | |
141 | get_m_n_optimized(1600000, 38400, &m, &n); | |
3776801d A |
142 | |
143 | printf("\nPER 1536000\n"); | |
28a181ff A |
144 | get_m_n_optimized(1536000, 12000, &m, &n); |
145 | get_m_n_optimized(1536000, 13000, &m, &n); | |
146 | get_m_n_optimized(1536000, 16800, &m, &n); | |
147 | get_m_n_optimized(1536000, 19200, &m, &n); | |
148 | get_m_n_optimized(1536000, 26000, &m, &n); | |
149 | get_m_n_optimized(1536000, 27000, &m, &n); | |
150 | get_m_n_optimized(1536000, 38400, &m, &n); | |
3776801d A |
151 | |
152 | printf("\nIVA 1862000\n"); | |
28a181ff A |
153 | get_m_n_optimized(1862000, 12000, &m, &n); |
154 | get_m_n_optimized(1862000, 13000, &m, &n); | |
155 | get_m_n_optimized(1862000, 16800, &m, &n); | |
156 | get_m_n_optimized(1862000, 19200, &m, &n); | |
157 | get_m_n_optimized(1862000, 26000, &m, &n); | |
158 | get_m_n_optimized(1862000, 27000, &m, &n); | |
159 | get_m_n_optimized(1862000, 38400, &m, &n); | |
160 | ||
161 | printf("\nIVA Nitro - 1290000\n"); | |
162 | get_m_n_optimized(1290000, 12000, &m, &n); | |
163 | get_m_n_optimized(1290000, 13000, &m, &n); | |
164 | get_m_n_optimized(1290000, 16800, &m, &n); | |
165 | get_m_n_optimized(1290000, 19200, &m, &n); | |
166 | get_m_n_optimized(1290000, 26000, &m, &n); | |
167 | get_m_n_optimized(1290000, 27000, &m, &n); | |
168 | get_m_n_optimized(1290000, 38400, &m, &n); | |
3776801d A |
169 | |
170 | printf("\nABE 196608 sys clk\n"); | |
28a181ff A |
171 | get_m_n_optimized(196608, 12000, &m, &n); |
172 | get_m_n_optimized(196608, 13000, &m, &n); | |
173 | get_m_n_optimized(196608, 16800, &m, &n); | |
174 | get_m_n_optimized(196608, 19200, &m, &n); | |
175 | get_m_n_optimized(196608, 26000, &m, &n); | |
176 | get_m_n_optimized(196608, 27000, &m, &n); | |
177 | get_m_n_optimized(196608, 38400, &m, &n); | |
3776801d A |
178 | |
179 | printf("\nABE 196608 32K\n"); | |
28a181ff | 180 | get_m_n_optimized(196608000/4, 32768, &m, &n); |
3776801d A |
181 | |
182 | printf("\nUSB 1920000\n"); | |
28a181ff A |
183 | get_m_n_optimized(1920000, 12000, &m, &n); |
184 | get_m_n_optimized(1920000, 13000, &m, &n); | |
185 | get_m_n_optimized(1920000, 16800, &m, &n); | |
186 | get_m_n_optimized(1920000, 19200, &m, &n); | |
187 | get_m_n_optimized(1920000, 26000, &m, &n); | |
188 | get_m_n_optimized(1920000, 27000, &m, &n); | |
189 | get_m_n_optimized(1920000, 38400, &m, &n); | |
3776801d A |
190 | |
191 | printf("\nCore ES1 1523712\n"); | |
28a181ff A |
192 | get_m_n_optimized(1524000, 12000, &m, &n); |
193 | get_m_n_optimized(1524000, 13000, &m, &n); | |
194 | get_m_n_optimized(1524000, 16800, &m, &n); | |
195 | get_m_n_optimized(1524000, 19200, &m, &n); | |
196 | get_m_n_optimized(1524000, 26000, &m, &n); | |
197 | get_m_n_optimized(1524000, 27000, &m, &n); | |
3776801d A |
198 | |
199 | /* exact recommendation for SDPs */ | |
28a181ff | 200 | get_m_n_optimized(1523712, 38400, &m, &n); |
3776801d A |
201 | |
202 | } |