1 /*
2 * Copyright (c) 2017, ARM Limited and Contributors. All rights reserved.
3 *
4 * SPDX-License-Identifier: BSD-3-Clause
5 */
6
7 #include <assert.h>
8 #include <errno.h>
9
10 #include <arch_helpers.h>
11 #include <common/debug.h>
12 #include <drivers/arm/sp804_delay_timer.h>
13 #include <lib/mmio.h>
14
15 #include <hi6220.h>
16 #include <hi6553.h>
17 #include <hisi_sram_map.h>
18 #include "hikey_private.h"
19
init_pll(void)20 static void init_pll(void)
21 {
22 unsigned int data;
23
24 data = mmio_read_32((0xf7032000 + 0x000));
25 data |= 0x1;
26 mmio_write_32((0xf7032000 + 0x000), data);
27 do {
28 data = mmio_read_32((0xf7032000 + 0x000));
29 } while (!(data & (1 << 28)));
30
31 data = mmio_read_32((0xf7800000 + 0x000));
32 data &= ~0x007;
33 data |= 0x004;
34 mmio_write_32((0xf7800000 + 0x000), data);
35 do {
36 data = mmio_read_32((0xf7800000 + 0x014));
37 data &= 0x007;
38 } while (data != 0x004);
39
40 mmio_write_32(PERI_SC_PERIPH_CTRL14, 0x2101);
41 dsb();
42 isb();
43 udelay(10);
44 mmio_write_32(PERI_SC_PERIPH_CTRL14, 0x2001);
45 dsb();
46 isb();
47 udelay(10);
48 mmio_write_32(PERI_SC_PERIPH_CTRL14, 0x2201);
49 dsb();
50 isb();
51 udelay(10);
52 mmio_write_32(0xf7032000 + 0x02c, 0x5110103e);
53 dsb();
54 isb();
55 udelay(10);
56 data = mmio_read_32(0xf7032000 + 0x050);
57 data |= 1 << 28;
58 mmio_write_32(0xf7032000 + 0x050, data);
59 dsb();
60 isb();
61 udelay(10);
62 mmio_write_32(PERI_SC_PERIPH_CTRL14, 0x2101);
63 dsb();
64 isb();
65 udelay(10);
66 mmio_write_32(PERI_SC_PERIPH_CTRL14, 0x2001);
67 dsb();
68 isb();
69 udelay(10);
70 mmio_write_32(PERI_SC_PERIPH_CTRL14, 0x2201);
71 dsb();
72 isb();
73 udelay(10);
74 }
75
init_freq(void)76 static void init_freq(void)
77 {
78 unsigned int data, tmp;
79 unsigned int cpuext_cfg, ddr_cfg;
80
81 mmio_write_32((0xf7032000 + 0x374), 0x4a);
82 mmio_write_32((0xf7032000 + 0x368), 0xda);
83 mmio_write_32((0xf7032000 + 0x36c), 0x01);
84 mmio_write_32((0xf7032000 + 0x370), 0x01);
85 mmio_write_32((0xf7032000 + 0x360), 0x60);
86 mmio_write_32((0xf7032000 + 0x364), 0x60);
87
88 mmio_write_32((0xf7032000 + 0x114), 0x1000);
89
90 data = mmio_read_32((0xf7032000 + 0x110));
91 data |= (3 << 12);
92 mmio_write_32((0xf7032000 + 0x110), data);
93
94 data = mmio_read_32((0xf7032000 + 0x110));
95 data |= (1 << 4);
96 mmio_write_32((0xf7032000 + 0x110), data);
97
98
99 data = mmio_read_32((0xf7032000 + 0x110));
100 data &= ~0x7;
101 data |= 0x5;
102 mmio_write_32((0xf7032000 + 0x110), data);
103 dsb();
104 mdelay(10);
105
106
107 do {
108 data = mmio_read_32((0xf6504000 + 0x008));
109 data &= (3 << 20);
110 } while (data != (3 << 20));
111 dsb();
112 mdelay(10);
113
114
115 data = mmio_read_32((0xf6504000 + 0x054));
116 data &= ~((1 << 0) | (1 << 11));
117 mmio_write_32((0xf6504000 + 0x054), data);
118 mdelay(10);
119
120 data = mmio_read_32((0xf7032000 + 0x104));
121 data &= ~(3 << 8);
122 data |= (1 << 8);
123 mmio_write_32((0xf7032000 + 0x104), data);
124
125 data = mmio_read_32((0xf7032000 + 0x100));
126 data |= (1 << 0);
127 mmio_write_32((0xf7032000 + 0x100), data);
128 dsb();
129
130 do {
131 data = mmio_read_32((0xf7032000 + 0x100));
132 data &= (1 << 2);
133 } while (data != (1 << 2));
134
135 data = mmio_read_32((0xf6504000 + 0x06c));
136 data &= ~0xffff;
137 data |= 0x56;
138 mmio_write_32((0xf6504000 + 0x06c), data);
139
140 data = mmio_read_32((0xf6504000 + 0x06c));
141 data &= ~(0xffffffu << 8);
142 data |= 0xc7a << 8;
143 mmio_write_32((0xf6504000 + 0x06c), data);
144
145 data = mmio_read_32((0xf6504000 + 0x058));
146 data &= ((1 << 13) - 1);
147 data |= 0xccb;
148 mmio_write_32((0xf6504000 + 0x058), data);
149
150 mmio_write_32((0xf6504000 + 0x060), 0x1fff);
151 mmio_write_32((0xf6504000 + 0x064), 0x1ffffff);
152 mmio_write_32((0xf6504000 + 0x068), 0x7fffffff);
153 mmio_write_32((0xf6504000 + 0x05c), 0x1);
154
155 data = mmio_read_32((0xf6504000 + 0x054));
156 data &= ~(0xf << 12);
157 data |= 1 << 12;
158 mmio_write_32((0xf6504000 + 0x054), data);
159 dsb();
160
161
162 data = mmio_read_32((0xf7032000 + 0x000));
163 data &= ~(1 << 0);
164 mmio_write_32((0xf7032000 + 0x000), data);
165
166 mmio_write_32((0xf7032000 + 0x004), 0x5110207d);
167 mmio_write_32((0xf7032000 + 0x134), 0x10000005);
168 data = mmio_read_32((0xf7032000 + 0x134));
169
170
171 data = mmio_read_32((0xf7032000 + 0x000));
172 data |= (1 << 0);
173 mmio_write_32((0xf7032000 + 0x000), data);
174
175 mmio_write_32((0xf7032000 + 0x368), 0x100da);
176 data = mmio_read_32((0xf7032000 + 0x378));
177 data &= ~((1 << 7) - 1);
178 data |= 0x6b;
179 mmio_write_32((0xf7032000 + 0x378), data);
180 dsb();
181 do {
182 data = mmio_read_32((0xf7032000 + 0x378));
183 tmp = data & 0x7f;
184 data = (data & (0x7f << 8)) >> 8;
185 if (data != tmp)
186 continue;
187 data = mmio_read_32((0xf7032000 + 0x37c));
188 } while (!(data & 1));
189
190 data = mmio_read_32((0xf7032000 + 0x104));
191 data &= ~((3 << 0) |
192 (3 << 8));
193 cpuext_cfg = 1;
194 ddr_cfg = 1;
195 data |= cpuext_cfg | (ddr_cfg << 8);
196 mmio_write_32((0xf7032000 + 0x104), data);
197 dsb();
198
199 do {
200 data = mmio_read_32((0xf7032000 + 0x104));
201 tmp = (data & (3 << 16)) >> 16;
202 if (cpuext_cfg != tmp)
203 continue;
204 tmp = (data & (3 << 24)) >> 24;
205 if (ddr_cfg != tmp)
206 continue;
207 data = mmio_read_32((0xf7032000 + 0x000));
208 data &= 1 << 28;
209 } while (!data);
210
211 data = mmio_read_32((0xf7032000 + 0x100));
212 data &= ~(1 << 0);
213 mmio_write_32((0xf7032000 + 0x100), data);
214 dsb();
215 do {
216 data = mmio_read_32((0xf7032000 + 0x100));
217 data &= (1 << 1);
218 } while (data != (1 << 1));
219 mdelay(1000);
220
221 data = mmio_read_32((0xf6504000 + 0x054));
222 data &= ~(1 << 28);
223 mmio_write_32((0xf6504000 + 0x054), data);
224 dsb();
225
226 data = mmio_read_32((0xf7032000 + 0x110));
227 data &= ~((1 << 4) |
228 (3 << 12));
229 mmio_write_32((0xf7032000 + 0x110), data);
230 }
231
cat_533mhz_800mhz(void)232 int cat_533mhz_800mhz(void)
233 {
234 unsigned int data, i;
235 unsigned int bdl[5];
236
237
238 data = mmio_read_32((0xf712c000 + 0x1c8));
239 data &= 0xfffff0f0;
240 data |= 0x100f01;
241 mmio_write_32((0xf712c000 + 0x1c8), data);
242
243 for (i = 0; i < 0x20; i++) {
244 mmio_write_32((0xf712c000 + 0x1d4), 0xc0000);
245 data = (i << 0x10) + i;
246 mmio_write_32((0xf712c000 + 0x140), data);
247 mmio_write_32((0xf712c000 + 0x144), data);
248 mmio_write_32((0xf712c000 + 0x148), data);
249 mmio_write_32((0xf712c000 + 0x14c), data);
250 mmio_write_32((0xf712c000 + 0x150), data);
251
252
253 data = mmio_read_32((0xf712c000 + 0x070));
254 data |= 0x80000;
255 mmio_write_32((0xf712c000 + 0x070), data);
256 data = mmio_read_32((0xf712c000 + 0x070));
257 data &= 0xfff7ffff;
258 mmio_write_32((0xf712c000 + 0x070), data);
259
260
261 mmio_write_32((0xf712c000 + 0x004), 0x8000);
262 mmio_write_32((0xf712c000 + 0x004), 0x0);
263 mmio_write_32((0xf712c000 + 0x004), 0x801);
264 do {
265 data = mmio_read_32((0xf712c000 + 0x004));
266 } while (data & 1);
267
268 data = mmio_read_32((0xf712c000 + 0x008));
269 if ((data & 0x400) == 0) {
270 mdelay(10);
271 return 0;
272 }
273 WARN("lpddr3 cat fail\n");
274 data = mmio_read_32((0xf712c000 + 0x1d4));
275 if ((data & 0x1f00) && ((data & 0x1f) == 0)) {
276 bdl[0] = mmio_read_32((0xf712c000 + 0x140));
277 bdl[1] = mmio_read_32((0xf712c000 + 0x144));
278 bdl[2] = mmio_read_32((0xf712c000 + 0x148));
279 bdl[3] = mmio_read_32((0xf712c000 + 0x14c));
280 bdl[4] = mmio_read_32((0xf712c000 + 0x150));
281 if ((!(bdl[0] & 0x1f001f)) || (!(bdl[1] & 0x1f001f)) ||
282 (!(bdl[2] & 0x1f001f)) || (!(bdl[3] & 0x1f001f)) ||
283 (!(bdl[4] & 0x1f001f))) {
284 WARN("lpddr3 cat deskew error\n");
285 if (i == 0x1f) {
286 WARN("addrnbdl is max\n");
287 return -EINVAL;
288 }
289 mmio_write_32((0xf712c000 + 0x008), 0x400);
290 } else {
291 WARN("lpddr3 cat other error1\n");
292 return -EINVAL;
293 }
294 } else {
295 WARN("lpddr3 cat other error2\n");
296 return -EINVAL;
297 }
298 }
299 return -EINVAL;
300 }
301
ddrx_rdet(void)302 static void ddrx_rdet(void)
303 {
304 unsigned int data, rdet, bdl[4];
305
306 data = mmio_read_32((0xf712c000 + 0x0d0));
307 data &= 0xf800ffff;
308 data |= 0x8f0000;
309 mmio_write_32((0xf712c000 + 0x0d0), data);
310
311 data = mmio_read_32((0xf712c000 + 0x0dc));
312 data &= 0xfffffff0;
313 data |= 0xf;
314 mmio_write_32((0xf712c000 + 0x0dc), data);
315
316
317 data = mmio_read_32((0xf712c000 + 0x070));
318 data |= 0x80000;
319 mmio_write_32((0xf712c000 + 0x070), data);
320 data = mmio_read_32((0xf712c000 + 0x070));
321 data &= 0xfff7ffff;
322 mmio_write_32((0xf712c000 + 0x070), data);
323
324 mmio_write_32((0xf712c000 + 0x004), 0x8000);
325 mmio_write_32((0xf712c000 + 0x004), 0);
326
327 data = mmio_read_32((0xf712c000 + 0x0d0));
328 data &= ~0xf0000000;
329 data |= 0x80000000;
330 mmio_write_32((0xf712c000 + 0x0d0), data);
331
332 mmio_write_32((0xf712c000 + 0x004), 0x101);
333 do {
334 data = mmio_read_32((0xf712c000 + 0x004));
335 } while (!(data & 1));
336 data = mmio_read_32((0xf712c000 + 0x008));
337 if (data & 0x100)
338 WARN("rdet lbs fail\n");
339
340 bdl[0] = mmio_read_32((0xf712c000 + 0x22c)) & 0x7f;
341 bdl[1] = mmio_read_32((0xf712c000 + 0x2ac)) & 0x7f;
342 bdl[2] = mmio_read_32((0xf712c000 + 0x32c)) & 0x7f;
343 bdl[3] = mmio_read_32((0xf712c000 + 0x3ac)) & 0x7f;
344 do {
345 data = mmio_read_32((0xf712c000 + 0x22c));
346 data &= ~0x7f;
347 data |= bdl[0];
348 mmio_write_32((0xf712c000 + 0x22c), data);
349 data = mmio_read_32((0xf712c000 + 0x2ac));
350 data &= ~0x7f;
351 data |= bdl[1];
352 mmio_write_32((0xf712c000 + 0x2ac), data);
353 data = mmio_read_32((0xf712c000 + 0x32c));
354 data &= ~0x7f;
355 data |= bdl[2];
356 mmio_write_32((0xf712c000 + 0x32c), data);
357 data = mmio_read_32((0xf712c000 + 0x3ac));
358 data &= ~0x7f;
359 data |= bdl[3];
360 mmio_write_32((0xf712c000 + 0x3ac), data);
361
362
363 data = mmio_read_32((0xf712c000 + 0x070));
364 data |= 0x80000;
365 mmio_write_32((0xf712c000 + 0x070), data);
366 data = mmio_read_32((0xf712c000 + 0x070));
367 data &= 0xfff7ffff;
368 mmio_write_32((0xf712c000 + 0x070), data);
369
370 mmio_write_32((0xf712c000 + 0x004), 0x8000);
371 mmio_write_32((0xf712c000 + 0x004), 0);
372
373 data = mmio_read_32((0xf712c000 + 0x0d0));
374 data &= ~0xf0000000;
375 data |= 0x40000000;
376 mmio_write_32((0xf712c000 + 0x0d0), data);
377 mmio_write_32((0xf712c000 + 0x004), 0x101);
378 do {
379 data = mmio_read_32((0xf712c000 + 0x004));
380 } while (data & 1);
381
382 data = mmio_read_32((0xf712c000 + 0x008));
383 rdet = data & 0x100;
384 if (rdet) {
385 INFO("rdet ds fail\n");
386 mmio_write_32((0xf712c000 + 0x008), 0x100);
387 }
388 bdl[0]++;
389 bdl[1]++;
390 bdl[2]++;
391 bdl[3]++;
392 } while (rdet);
393
394 data = mmio_read_32((0xf712c000 + 0x0d0));
395 data &= ~0xf0000000;
396 data |= 0x30000000;
397 mmio_write_32((0xf712c000 + 0x0d0), data);
398
399 mmio_write_32((0xf712c000 + 0x004), 0x101);
400 do {
401 data = mmio_read_32((0xf712c000 + 0x004));
402 } while (data & 1);
403 data = mmio_read_32((0xf712c000 + 0x008));
404 if (data & 0x100)
405 INFO("rdet rbs av fail\n");
406 }
407
ddrx_wdet(void)408 static void ddrx_wdet(void)
409 {
410 unsigned int data, wdet, zero_bdl = 0, dq[4];
411 int i;
412
413 data = mmio_read_32((0xf712c000 + 0x0d0));
414 data &= ~0xf;
415 data |= 0xf;
416 mmio_write_32((0xf712c000 + 0x0d0), data);
417
418 data = mmio_read_32((0xf712c000 + 0x070));
419 data |= 0x80000;
420 mmio_write_32((0xf712c000 + 0x070), data);
421 data = mmio_read_32((0xf712c000 + 0x070));
422 data &= ~0x80000;
423 mmio_write_32((0xf712c000 + 0x070), data);
424
425 mmio_write_32((0xf712c000 + 0x004), 0x8000);
426 mmio_write_32((0xf712c000 + 0x004), 0);
427 data = mmio_read_32((0xf712c000 + 0x0d0));
428 data &= ~0xf000;
429 data |= 0x8000;
430 mmio_write_32((0xf712c000 + 0x0d0), data);
431 mmio_write_32((0xf712c000 + 0x004), 0x201);
432 do {
433 data = mmio_read_32((0xf712c000 + 0x004));
434 } while (data & 1);
435 data = mmio_read_32((0xf712c000 + 0x008));
436 if (data & 0x200)
437 INFO("wdet lbs fail\n");
438
439 dq[0] = mmio_read_32((0xf712c000 + 0x234)) & 0x1f00;
440 dq[1] = mmio_read_32((0xf712c000 + 0x2b4)) & 0x1f00;
441 dq[2] = mmio_read_32((0xf712c000 + 0x334)) & 0x1f00;
442 dq[3] = mmio_read_32((0xf712c000 + 0x3b4)) & 0x1f00;
443
444 do {
445 mmio_write_32((0xf712c000 + 0x234), dq[0]);
446 mmio_write_32((0xf712c000 + 0x2b4), dq[1]);
447 mmio_write_32((0xf712c000 + 0x334), dq[2]);
448 mmio_write_32((0xf712c000 + 0x3b4), dq[3]);
449
450 data = mmio_read_32((0xf712c000 + 0x070));
451 data |= 0x80000;
452 mmio_write_32((0xf712c000 + 0x070), data);
453 data = mmio_read_32((0xf712c000 + 0x070));
454 data &= ~0x80000;
455 mmio_write_32((0xf712c000 + 0x070), data);
456 mmio_write_32((0xf712c000 + 0x004), 0x8000);
457 mmio_write_32((0xf712c000 + 0x004), 0);
458
459 data = mmio_read_32((0xf712c000 + 0x0d0));
460 data &= ~0xf000;
461 data |= 0x4000;
462 mmio_write_32((0xf712c000 + 0x0d0), data);
463 mmio_write_32((0xf712c000 + 0x004), 0x201);
464 do {
465 data = mmio_read_32((0xf712c000 + 0x004));
466 } while (data & 1);
467
468 data = mmio_read_32((0xf712c000 + 0x008));
469 wdet = data & 0x200;
470 if (wdet) {
471 INFO("wdet ds fail\n");
472 mmio_write_32((0xf712c000 + 0x008), 0x200);
473 }
474 mdelay(10);
475
476 for (i = 0; i < 4; i++) {
477 data = mmio_read_32((0xf712c000 + 0x210 + i * 0x80));
478 if ((!(data & 0x1f)) || (!(data & 0x1f00)) ||
479 (!(data & 0x1f0000)) || (!(data & 0x1f000000)))
480 zero_bdl = 1;
481 data = mmio_read_32((0xf712c000 + 0x214 + i * 0x80));
482 if ((!(data & 0x1f)) || (!(data & 0x1f00)) ||
483 (!(data & 0x1f0000)) || (!(data & 0x1f000000)))
484 zero_bdl = 1;
485 data = mmio_read_32((0xf712c000 + 0x218 + i * 0x80));
486 if (!(data & 0x1f))
487 zero_bdl = 1;
488 if (zero_bdl) {
489 if (i == 0)
490 dq[0] = dq[0] - 0x100;
491 if (i == 1)
492 dq[1] = dq[1] - 0x100;
493 if (i == 2)
494 dq[2] = dq[2] - 0x100;
495 if (i == 3)
496 dq[3] = dq[3] - 0x100;
497 }
498 }
499 } while (wdet);
500
501 data = mmio_read_32((0xf712c000 + 0x0d0));
502 data &= ~0xf000;
503 data |= 0x3000;
504 mmio_write_32((0xf712c000 + 0x0d0), data);
505 mmio_write_32((0xf712c000 + 0x004), 0x201);
506 do {
507 data = mmio_read_32((0xf712c000 + 0x004));
508 } while (data & 1);
509 data = mmio_read_32((0xf712c000 + 0x008));
510 if (data & 0x200)
511 INFO("wdet rbs av fail\n");
512 }
513
set_ddrc_150mhz(void)514 void set_ddrc_150mhz(void)
515 {
516 unsigned int data;
517
518 mmio_write_32((0xf7032000 + 0x580), 0x1);
519 mmio_write_32((0xf7032000 + 0x5a8), 0x7);
520 data = mmio_read_32((0xf7032000 + 0x104));
521 data &= 0xfffffcff;
522 mmio_write_32((0xf7032000 + 0x104), data);
523
524 mmio_write_32((0xf7030000 + 0x050), 0x31);
525 mmio_write_32((0xf7030000 + 0x240), 0x5ffff);
526 mmio_write_32((0xf7030000 + 0x344), 0xf5ff);
527 mmio_write_32((0xf712c000 + 0x00c), 0x80000f0f);
528 mmio_write_32((0xf712c000 + 0x00c), 0xf0f);
529 mmio_write_32((0xf712c000 + 0x018), 0x7);
530 mmio_write_32((0xf712c000 + 0x090), 0x7200000);
531 mmio_write_32((0xf712c000 + 0x258), 0x720);
532 mmio_write_32((0xf712c000 + 0x2d8), 0x720);
533 mmio_write_32((0xf712c000 + 0x358), 0x720);
534 mmio_write_32((0xf712c000 + 0x3d8), 0x720);
535 mmio_write_32((0xf712c000 + 0x018), 0x7);
536 mmio_write_32((0xf712c000 + 0x0b0), 0xf00000f);
537 mmio_write_32((0xf712c000 + 0x0b4), 0xf);
538 mmio_write_32((0xf712c000 + 0x088), 0x3fff801);
539 mmio_write_32((0xf712c000 + 0x070), 0x8940000);
540
541 data = mmio_read_32((0xf712c000 + 0x078));
542 data |= 4;
543 mmio_write_32((0xf712c000 + 0x078), data);
544 mmio_write_32((0xf712c000 + 0x01c), 0x8000080);
545 data = mmio_read_32((0xf712c000 + 0x020));
546 data &= 0xfffffffe;
547 mmio_write_32((0xf712c000 + 0x020), data);
548 mmio_write_32((0xf712c000 + 0x1d4), 0xc0000);
549 mmio_write_32((0xf712c000 + 0x010), 0x500000f);
550 mmio_write_32((0xf712c000 + 0x014), 0x10);
551 data = mmio_read_32((0xf712c000 + 0x1e4));
552 data &= 0xffffff00;
553 mmio_write_32((0xf712c000 + 0x1e4), data);
554 mmio_write_32((0xf712c000 + 0x030), 0x30c82355);
555 mmio_write_32((0xf712c000 + 0x034), 0x62112bb);
556 mmio_write_32((0xf712c000 + 0x038), 0x20041022);
557 mmio_write_32((0xf712c000 + 0x03c), 0x63177497);
558 mmio_write_32((0xf712c000 + 0x040), 0x3008407);
559 mmio_write_32((0xf712c000 + 0x064), 0x10483);
560 mmio_write_32((0xf712c000 + 0x068), 0xff0a0000);
561 data = mmio_read_32((0xf712c000 + 0x070));
562 data &= 0xffff0000;
563 data |= 0x184;
564 mmio_write_32((0xf712c000 + 0x070), data);
565 data = mmio_read_32((0xf712c000 + 0x048));
566 data &= 0xbfffffff;
567 mmio_write_32((0xf712c000 + 0x048), data);
568 data = mmio_read_32((0xf712c000 + 0x020));
569 data &= ~0x10;
570 mmio_write_32((0xf712c000 + 0x020), data);
571 data = mmio_read_32((0xf712c000 + 0x080));
572 data &= ~0x2000;
573 mmio_write_32((0xf712c000 + 0x080), data);
574 mmio_write_32((0xf712c000 + 0x270), 0x3);
575 mmio_write_32((0xf712c000 + 0x2f0), 0x3);
576 mmio_write_32((0xf712c000 + 0x370), 0x3);
577 mmio_write_32((0xf712c000 + 0x3f0), 0x3);
578 mmio_write_32((0xf712c000 + 0x048), 0x90420880);
579
580 mmio_write_32((0xf7128000 + 0x040), 0x0);
581 mmio_write_32((0xf712c000 + 0x004), 0x146d);
582 mmio_write_32((0xf7128000 + 0x050), 0x100123);
583 mmio_write_32((0xf7128000 + 0x060), 0x133);
584 mmio_write_32((0xf7128000 + 0x064), 0x133);
585 mmio_write_32((0xf7128000 + 0x200), 0xa1000);
586
587 mmio_write_32((0xf7128000 + 0x100), 0xb3290d08);
588 mmio_write_32((0xf7128000 + 0x104), 0x9621821);
589 mmio_write_32((0xf7128000 + 0x108), 0x45009023);
590 mmio_write_32((0xf7128000 + 0x10c), 0xaf44c145);
591 mmio_write_32((0xf7128000 + 0x110), 0x10b00000);
592 mmio_write_32((0xf7128000 + 0x114), 0x11080806);
593 mmio_write_32((0xf7128000 + 0x118), 0x44);
594 do {
595 data = mmio_read_32((0xf712c000 + 0x004));
596 } while (data & 1);
597 data = mmio_read_32((0xf712c000 + 0x008));
598 if (data & 8) {
599 NOTICE("fail to init ddr3 rank0\n");
600 return;
601 }
602
603 data = mmio_read_32((0xf712c000 + 0x048));
604 data |= 1;
605 mmio_write_32((0xf712c000 + 0x048), data);
606 mmio_write_32((0xf712c000 + 0x004), 0x21);
607 do {
608 data = mmio_read_32((0xf712c000 + 0x004));
609 } while (data & 1);
610
611 data = mmio_read_32((0xf712c000 + 0x008));
612 if (data & 0x8)
613 NOTICE("ddr3 rank1 init failure\n");
614 else
615 INFO("ddr3 rank1 init pass\n");
616
617 data = mmio_read_32((0xf712c000 + 0x048));
618 data &= ~0xf;
619 mmio_write_32((0xf712c000 + 0x048), data);
620 INFO("succeed to set ddrc 150mhz\n");
621 }
622
set_ddrc_266mhz(void)623 void set_ddrc_266mhz(void)
624 {
625 unsigned int data;
626
627 mmio_write_32((0xf7032000 + 0x580), 0x3);
628 mmio_write_32((0xf7032000 + 0x5a8), 0x1003);
629 data = mmio_read_32((0xf7032000 + 0x104));
630 data &= 0xfffffcff;
631 mmio_write_32((0xf7032000 + 0x104), data);
632
633 mmio_write_32((0xf7030000 + 0x050), 0x31);
634 mmio_write_32((0xf7030000 + 0x240), 0x5ffff);
635 mmio_write_32((0xf7030000 + 0x344), 0xf5ff);
636 mmio_write_32((0xf712c000 + 0x00c), 0x80000f0f);
637 mmio_write_32((0xf712c000 + 0x00c), 0xf0f);
638 mmio_write_32((0xf712c000 + 0x018), 0x7);
639 mmio_write_32((0xf712c000 + 0x090), 0x7200000);
640 mmio_write_32((0xf712c000 + 0x258), 0x720);
641 mmio_write_32((0xf712c000 + 0x2d8), 0x720);
642 mmio_write_32((0xf712c000 + 0x358), 0x720);
643 mmio_write_32((0xf712c000 + 0x3d8), 0x720);
644 mmio_write_32((0xf712c000 + 0x018), 0x7);
645 mmio_write_32((0xf712c000 + 0x0b0), 0xf00000f);
646 mmio_write_32((0xf712c000 + 0x0b4), 0xf);
647 mmio_write_32((0xf712c000 + 0x088), 0x3fff801);
648 mmio_write_32((0xf712c000 + 0x070), 0x8940000);
649
650 data = mmio_read_32((0xf712c000 + 0x078));
651 data |= 4;
652 mmio_write_32((0xf712c000 + 0x078), data);
653 mmio_write_32((0xf712c000 + 0x01c), 0x8000080);
654 data = mmio_read_32((0xf712c000 + 0x020));
655 data &= 0xfffffffe;
656 mmio_write_32((0xf712c000 + 0x020), data);
657 mmio_write_32((0xf712c000 + 0x1d4), 0xc0000);
658 mmio_write_32((0xf712c000 + 0x010), 0x500000f);
659 mmio_write_32((0xf712c000 + 0x014), 0x10);
660 data = mmio_read_32((0xf712c000 + 0x1e4));
661 data &= 0xffffff00;
662 mmio_write_32((0xf712c000 + 0x1e4), data);
663 mmio_write_32((0xf712c000 + 0x030), 0x510d4455);
664 mmio_write_32((0xf712c000 + 0x034), 0x8391ebb);
665 mmio_write_32((0xf712c000 + 0x038), 0x2005103c);
666 mmio_write_32((0xf712c000 + 0x03c), 0x6329950b);
667 mmio_write_32((0xf712c000 + 0x040), 0x300858c);
668 mmio_write_32((0xf712c000 + 0x064), 0x10483);
669 mmio_write_32((0xf712c000 + 0x068), 0xff0a0000);
670 data = mmio_read_32((0xf712c000 + 0x070));
671 data &= 0xffff0000;
672 data |= 0x184;
673 mmio_write_32((0xf712c000 + 0x070), data);
674 data = mmio_read_32((0xf712c000 + 0x048));
675 data &= 0xbfffffff;
676 mmio_write_32((0xf712c000 + 0x048), data);
677 data = mmio_read_32((0xf712c000 + 0x020));
678 data &= ~0x10;
679 mmio_write_32((0xf712c000 + 0x020), data);
680 data = mmio_read_32((0xf712c000 + 0x080));
681 data &= ~0x2000;
682 mmio_write_32((0xf712c000 + 0x080), data);
683 mmio_write_32((0xf712c000 + 0x270), 0x3);
684 mmio_write_32((0xf712c000 + 0x2f0), 0x3);
685 mmio_write_32((0xf712c000 + 0x370), 0x3);
686 mmio_write_32((0xf712c000 + 0x3f0), 0x3);
687 mmio_write_32((0xf712c000 + 0x048), 0x90420880);
688
689 mmio_write_32((0xf7128000 + 0x040), 0x0);
690 mmio_write_32((0xf712c000 + 0x004), 0x146d);
691 mmio_write_32((0xf7128000 + 0x050), 0x100123);
692 mmio_write_32((0xf7128000 + 0x060), 0x133);
693 mmio_write_32((0xf7128000 + 0x064), 0x133);
694 mmio_write_32((0xf7128000 + 0x200), 0xa1000);
695
696 mmio_write_32((0xf7128000 + 0x100), 0xb441d50d);
697 mmio_write_32((0xf7128000 + 0x104), 0xf721839);
698 mmio_write_32((0xf7128000 + 0x108), 0x5500f03f);
699 mmio_write_32((0xf7128000 + 0x10c), 0xaf486145);
700 mmio_write_32((0xf7128000 + 0x110), 0x10b00000);
701 mmio_write_32((0xf7128000 + 0x114), 0x12080d06);
702 mmio_write_32((0xf7128000 + 0x118), 0x44);
703 do {
704 data = mmio_read_32((0xf712c000 + 0x004));
705 } while (data & 1);
706 data = mmio_read_32((0xf712c000 + 0x008));
707 if (data & 8) {
708 NOTICE("fail to init ddr3 rank0\n");
709 return;
710 }
711
712 data = mmio_read_32((0xf712c000 + 0x048));
713 data |= 1;
714 mmio_write_32((0xf712c000 + 0x048), data);
715 mmio_write_32((0xf712c000 + 0x004), 0x21);
716 do {
717 data = mmio_read_32((0xf712c000 + 0x004));
718 } while (data & 1);
719
720 data = mmio_read_32((0xf712c000 + 0x008));
721 if (data & 0x8)
722 NOTICE("ddr3 rank1 init failure\n");
723 else
724 INFO("ddr3 rank1 init pass\n");
725
726 data = mmio_read_32((0xf712c000 + 0x048));
727 data &= ~0xf;
728 mmio_write_32((0xf712c000 + 0x048), data);
729 INFO("succeed to set ddrc 266mhz\n");
730 }
731
set_ddrc_400mhz(void)732 void set_ddrc_400mhz(void)
733 {
734 unsigned int data;
735
736 mmio_write_32((0xf7032000 + 0x580), 0x2);
737 mmio_write_32((0xf7032000 + 0x5a8), 0x1003);
738 data = mmio_read_32((0xf7032000 + 0x104));
739 data &= 0xfffffcff;
740 mmio_write_32((0xf7032000 + 0x104), data);
741
742 mmio_write_32((0xf7030000 + 0x050), 0x31);
743 mmio_write_32((0xf7030000 + 0x240), 0x5ffff);
744 mmio_write_32((0xf7030000 + 0x344), 0xf5ff);
745 mmio_write_32((0xf712c000 + 0x00c), 0x80000f0f);
746 mmio_write_32((0xf712c000 + 0x00c), 0xf0f);
747 mmio_write_32((0xf712c000 + 0x018), 0x7);
748 mmio_write_32((0xf712c000 + 0x090), 0x7200000);
749 mmio_write_32((0xf712c000 + 0x258), 0x720);
750 mmio_write_32((0xf712c000 + 0x2d8), 0x720);
751 mmio_write_32((0xf712c000 + 0x358), 0x720);
752 mmio_write_32((0xf712c000 + 0x3d8), 0x720);
753 mmio_write_32((0xf712c000 + 0x018), 0x7);
754 mmio_write_32((0xf712c000 + 0x0b0), 0xf00000f);
755 mmio_write_32((0xf712c000 + 0x0b4), 0xf);
756 mmio_write_32((0xf712c000 + 0x088), 0x3fff801);
757 mmio_write_32((0xf712c000 + 0x070), 0x8940000);
758
759 data = mmio_read_32((0xf712c000 + 0x078));
760 data |= 4;
761 mmio_write_32((0xf712c000 + 0x078), data);
762 mmio_write_32((0xf712c000 + 0x01c), 0x8000080);
763 data = mmio_read_32((0xf712c000 + 0x020));
764 data &= 0xfffffffe;
765 mmio_write_32((0xf712c000 + 0x020), data);
766 mmio_write_32((0xf712c000 + 0x1d4), 0xc0000);
767 mmio_write_32((0xf712c000 + 0x010), 0x500000f);
768 mmio_write_32((0xf712c000 + 0x014), 0x10);
769 data = mmio_read_32((0xf712c000 + 0x1e4));
770 data &= 0xffffff00;
771 mmio_write_32((0xf712c000 + 0x1e4), data);
772 mmio_write_32((0xf712c000 + 0x030), 0x75525655);
773 mmio_write_32((0xf712c000 + 0x034), 0xa552abb);
774 mmio_write_32((0xf712c000 + 0x038), 0x20071059);
775 mmio_write_32((0xf712c000 + 0x03c), 0x633e8591);
776 mmio_write_32((0xf712c000 + 0x040), 0x3008691);
777 mmio_write_32((0xf712c000 + 0x064), 0x10483);
778 mmio_write_32((0xf712c000 + 0x068), 0xff0a0000);
779 data = mmio_read_32((0xf712c000 + 0x070));
780 data &= 0xffff0000;
781 data |= 0x184;
782 mmio_write_32((0xf712c000 + 0x070), data);
783 data = mmio_read_32((0xf712c000 + 0x048));
784 data &= 0xbfffffff;
785 mmio_write_32((0xf712c000 + 0x048), data);
786 data = mmio_read_32((0xf712c000 + 0x020));
787 data &= ~0x10;
788 mmio_write_32((0xf712c000 + 0x020), data);
789 data = mmio_read_32((0xf712c000 + 0x080));
790 data &= ~0x2000;
791 mmio_write_32((0xf712c000 + 0x080), data);
792 mmio_write_32((0xf712c000 + 0x270), 0x3);
793 mmio_write_32((0xf712c000 + 0x2f0), 0x3);
794 mmio_write_32((0xf712c000 + 0x370), 0x3);
795 mmio_write_32((0xf712c000 + 0x3f0), 0x3);
796 mmio_write_32((0xf712c000 + 0x048), 0x90420880);
797
798 mmio_write_32((0xf7128000 + 0x040), 0x0);
799 mmio_write_32((0xf712c000 + 0x004), 0x146d);
800 mmio_write_32((0xf7128000 + 0x050), 0x100123);
801 mmio_write_32((0xf7128000 + 0x060), 0x133);
802 mmio_write_32((0xf7128000 + 0x064), 0x133);
803 mmio_write_32((0xf7128000 + 0x200), 0xa1000);
804
805 mmio_write_32((0xf7128000 + 0x100), 0xb55a9d12);
806 mmio_write_32((0xf7128000 + 0x104), 0x17721855);
807 mmio_write_32((0xf7128000 + 0x108), 0x7501505f);
808 mmio_write_32((0xf7128000 + 0x10c), 0xaf4ca245);
809 mmio_write_32((0xf7128000 + 0x110), 0x10b00000);
810 mmio_write_32((0xf7128000 + 0x114), 0x13081306);
811 mmio_write_32((0xf7128000 + 0x118), 0x44);
812 do {
813 data = mmio_read_32((0xf712c000 + 0x004));
814 } while (data & 1);
815 data = mmio_read_32((0xf712c000 + 0x008));
816 if (data & 8) {
817 NOTICE("fail to init ddr3 rank0\n");
818 return;
819 }
820
821 data = mmio_read_32((0xf712c000 + 0x048));
822 data |= 1;
823 mmio_write_32((0xf712c000 + 0x048), data);
824 mmio_write_32((0xf712c000 + 0x004), 0x21);
825 do {
826 data = mmio_read_32((0xf712c000 + 0x004));
827 } while (data & 1);
828
829 data = mmio_read_32((0xf712c000 + 0x008));
830 if (data & 0x8)
831 NOTICE("ddr3 rank1 init failure\n");
832 else
833 INFO("ddr3 rank1 init pass\n");
834
835 data = mmio_read_32((0xf712c000 + 0x048));
836 data &= ~0xf;
837 mmio_write_32((0xf712c000 + 0x048), data);
838 INFO("succeed to set ddrc 400mhz\n");
839 }
840
set_ddrc_533mhz(void)841 void set_ddrc_533mhz(void)
842 {
843 unsigned int data;
844
845 mmio_write_32((0xf7032000 + 0x580), 0x3);
846 mmio_write_32((0xf7032000 + 0x5a8), 0x11111);
847 data = mmio_read_32((0xf7032000 + 0x104));
848 data |= 0x100;
849 mmio_write_32((0xf7032000 + 0x104), data);
850
851 mmio_write_32((0xf7030000 + 0x050), 0x30);
852 mmio_write_32((0xf7030000 + 0x240), 0x5ffff);
853 mmio_write_32((0xf7030000 + 0x344), 0xf5ff);
854 mmio_write_32((0xf712c000 + 0x00c), 0x400);
855 mmio_write_32((0xf712c000 + 0x00c), 0x400);
856 mmio_write_32((0xf712c000 + 0x018), 0x7);
857 mmio_write_32((0xf712c000 + 0x090), 0x6400000);
858 mmio_write_32((0xf712c000 + 0x258), 0x640);
859 mmio_write_32((0xf712c000 + 0x2d8), 0x640);
860 mmio_write_32((0xf712c000 + 0x358), 0x640);
861 mmio_write_32((0xf712c000 + 0x3d8), 0x640);
862 mmio_write_32((0xf712c000 + 0x018), 0x0);
863 mmio_write_32((0xf712c000 + 0x0b0), 0xf00000f);
864 mmio_write_32((0xf712c000 + 0x0b4), 0xf);
865 mmio_write_32((0xf712c000 + 0x088), 0x3fff801);
866 mmio_write_32((0xf712c000 + 0x070), 0x8940000);
867
868 data = mmio_read_32((0xf712c000 + 0x078));
869 data |= 4;
870 mmio_write_32((0xf712c000 + 0x078), data);
871 mmio_write_32((0xf712c000 + 0x01c), 0x8000080);
872 data = mmio_read_32((0xf712c000 + 0x020));
873 data &= 0xfffffffe;
874 mmio_write_32((0xf712c000 + 0x020), data);
875 mmio_write_32((0xf712c000 + 0x1d4), 0xc0000);
876 mmio_write_32((0xf712c000 + 0x010), 0x500000f);
877 mmio_write_32((0xf712c000 + 0x014), 0x10);
878 data = mmio_read_32((0xf712c000 + 0x1e4));
879 data &= 0xffffff00;
880 mmio_write_32((0xf712c000 + 0x1e4), data);
881 mmio_write_32((0xf712c000 + 0x030), 0x9dd87855);
882 mmio_write_32((0xf712c000 + 0x034), 0xa7138bb);
883 mmio_write_32((0xf712c000 + 0x038), 0x20091477);
884 mmio_write_32((0xf712c000 + 0x03c), 0x84534e16);
885 mmio_write_32((0xf712c000 + 0x040), 0x3008817);
886 mmio_write_32((0xf712c000 + 0x064), 0x106c3);
887 mmio_write_32((0xf712c000 + 0x068), 0xff0a0000);
888 data = mmio_read_32((0xf712c000 + 0x070));
889 data &= 0xffff0000;
890 data |= 0x305;
891 mmio_write_32((0xf712c000 + 0x070), data);
892 data = mmio_read_32((0xf712c000 + 0x048));
893 data |= 0x40000000;
894 mmio_write_32((0xf712c000 + 0x048), data);
895 data = mmio_read_32((0xf712c000 + 0x020));
896 data &= ~0x10;
897 mmio_write_32((0xf712c000 + 0x020), data);
898 data = mmio_read_32((0xf712c000 + 0x080));
899 data &= ~0x2000;
900 mmio_write_32((0xf712c000 + 0x080), data);
901 mmio_write_32((0xf712c000 + 0x270), 0x3);
902 mmio_write_32((0xf712c000 + 0x2f0), 0x3);
903 mmio_write_32((0xf712c000 + 0x370), 0x3);
904 mmio_write_32((0xf712c000 + 0x3f0), 0x3);
905 mmio_write_32((0xf712c000 + 0x048), 0xd0420900);
906
907 mmio_write_32((0xf7128000 + 0x040), 0x0);
908 mmio_write_32((0xf712c000 + 0x004), 0x140f);
909 do {
910 data = mmio_read_32((0xf712c000 + 0x004));
911 } while (data & 1);
912 data = mmio_read_32((0xf712c000 + 0x008));
913 if (data & 0x7fe) {
914 NOTICE("failed to init lpddr3 rank0 dram phy\n");
915 return;
916 }
917 cat_533mhz_800mhz();
918
919 mmio_write_32((0xf712c000 + 0x004), 0xf1);
920 mmio_write_32((0xf7128000 + 0x050), 0x100123);
921 mmio_write_32((0xf7128000 + 0x060), 0x133);
922 mmio_write_32((0xf7128000 + 0x064), 0x133);
923 mmio_write_32((0xf7128000 + 0x200), 0xa1000);
924
925 mmio_write_32((0xf7128000 + 0x100), 0xb77b6718);
926 mmio_write_32((0xf7128000 + 0x104), 0x1e82a071);
927 mmio_write_32((0xf7128000 + 0x108), 0x9501c07e);
928 mmio_write_32((0xf7128000 + 0x10c), 0xaf50c255);
929 mmio_write_32((0xf7128000 + 0x110), 0x10b00000);
930 mmio_write_32((0xf7128000 + 0x114), 0x13181908);
931 mmio_write_32((0xf7128000 + 0x118), 0x44);
932 do {
933 data = mmio_read_32((0xf712c000 + 0x004));
934 } while (data & 1);
935 data = mmio_read_32((0xf712c000 + 0x008));
936 if (data & 0x7fe) {
937 NOTICE("fail to init ddr3 rank0\n");
938 return;
939 }
940 ddrx_rdet();
941 ddrx_wdet();
942
943 data = mmio_read_32((0xf712c000 + 0x048));
944 data |= 1;
945 mmio_write_32((0xf712c000 + 0x048), data);
946 mmio_write_32((0xf712c000 + 0x004), 0x21);
947 do {
948 data = mmio_read_32((0xf712c000 + 0x004));
949 } while (data & 1);
950
951 data = mmio_read_32((0xf712c000 + 0x008));
952 if (data & 0x7fe)
953 NOTICE("ddr3 rank1 init failure\n");
954 else
955 INFO("ddr3 rank1 init pass\n");
956
957 data = mmio_read_32((0xf712c000 + 0x048));
958 data &= ~0xf;
959 mmio_write_32((0xf712c000 + 0x048), data);
960 INFO("succeed to set ddrc 533mhz\n");
961 }
962
set_ddrc_800mhz(void)963 void set_ddrc_800mhz(void)
964 {
965 unsigned int data;
966
967 mmio_write_32((0xf7032000 + 0x580), 0x2);
968 mmio_write_32((0xf7032000 + 0x5a8), 0x1003);
969 data = mmio_read_32((0xf7032000 + 0x104));
970 data &= 0xfffffcff;
971 mmio_write_32((0xf7032000 + 0x104), data);
972
973 mmio_write_32((0xf7030000 + 0x050), 0x30);
974 mmio_write_32((0xf7030000 + 0x240), 0x5ffff);
975 mmio_write_32((0xf7030000 + 0x344), 0xf5ff);
976 mmio_write_32((0xf712c000 + 0x00c), 0x400);
977 mmio_write_32((0xf712c000 + 0x00c), 0x400);
978 mmio_write_32((0xf712c000 + 0x018), 0x7);
979 mmio_write_32((0xf712c000 + 0x090), 0x5400000);
980 mmio_write_32((0xf712c000 + 0x258), 0x540);
981 mmio_write_32((0xf712c000 + 0x2d8), 0x540);
982 mmio_write_32((0xf712c000 + 0x358), 0x540);
983 mmio_write_32((0xf712c000 + 0x3d8), 0x540);
984 mmio_write_32((0xf712c000 + 0x018), 0x0);
985 mmio_write_32((0xf712c000 + 0x0b0), 0xf00000f);
986 mmio_write_32((0xf712c000 + 0x0b4), 0xf);
987 mmio_write_32((0xf712c000 + 0x088), 0x3fff801);
988 mmio_write_32((0xf712c000 + 0x070), 0x8940000);
989
990 data = mmio_read_32((0xf712c000 + 0x078));
991 data |= 4;
992 mmio_write_32((0xf712c000 + 0x078), data);
993 mmio_write_32((0xf712c000 + 0x01c), 0x8000080);
994 data = mmio_read_32((0xf712c000 + 0x020));
995 data &= 0xfffffffe;
996 mmio_write_32((0xf712c000 + 0x020), data);
997 mmio_write_32((0xf712c000 + 0x1d4), 0xc0000);
998 mmio_write_32((0xf712c000 + 0x010), 0x500000f);
999 mmio_write_32((0xf712c000 + 0x014), 0x10);
1000 data = mmio_read_32((0xf712c000 + 0x1e4));
1001 data &= 0xffffff00;
1002 mmio_write_32((0xf712c000 + 0x1e4), data);
1003 mmio_write_32((0xf712c000 + 0x030), 0xe663ab77);
1004 mmio_write_32((0xf712c000 + 0x034), 0xea952db);
1005 mmio_write_32((0xf712c000 + 0x038), 0x200d1cb1);
1006 mmio_write_32((0xf712c000 + 0x03c), 0xc67d0721);
1007 mmio_write_32((0xf712c000 + 0x040), 0x3008aa1);
1008 mmio_write_32((0xf712c000 + 0x064), 0x11a43);
1009 mmio_write_32((0xf712c000 + 0x068), 0xff0a0000);
1010 data = mmio_read_32((0xf712c000 + 0x070));
1011 data &= 0xffff0000;
1012 data |= 0x507;
1013 mmio_write_32((0xf712c000 + 0x070), data);
1014 data = mmio_read_32((0xf712c000 + 0x048));
1015 data |= 0x40000000;
1016 mmio_write_32((0xf712c000 + 0x048), data);
1017 data = mmio_read_32((0xf712c000 + 0x020));
1018 data &= 0xffffffef;
1019 mmio_write_32((0xf712c000 + 0x020), data);
1020 data = mmio_read_32((0xf712c000 + 0x080));
1021 data &= 0xffffdfff;
1022 mmio_write_32((0xf712c000 + 0x080), data);
1023 mmio_write_32((0xf712c000 + 0x270), 0x3);
1024 mmio_write_32((0xf712c000 + 0x2f0), 0x3);
1025 mmio_write_32((0xf712c000 + 0x370), 0x3);
1026 mmio_write_32((0xf712c000 + 0x3f0), 0x3);
1027 mmio_write_32((0xf712c000 + 0x048), 0xd0420900);
1028
1029 mmio_write_32((0xf7128000 + 0x040), 0x2001);
1030 mmio_write_32((0xf712c000 + 0x004), 0x140f);
1031 do {
1032 data = mmio_read_32((0xf712c000 + 0x004));
1033 } while (data & 1);
1034 data = mmio_read_32((0xf712c000 + 0x008));
1035 if (data & 0x7fe) {
1036 WARN("failed to init lpddr3 rank0 dram phy\n");
1037 return;
1038 }
1039 cat_533mhz_800mhz();
1040
1041 mmio_write_32((0xf712c000 + 0x004), 0xf1);
1042 mmio_write_32((0xf7128000 + 0x050), 0x100023);
1043 mmio_write_32((0xf7128000 + 0x060), 0x133);
1044 mmio_write_32((0xf7128000 + 0x064), 0x133);
1045 mmio_write_32((0xf7128000 + 0x200), 0xa1000);
1046
1047 mmio_write_32((0xf7128000 + 0x100), 0x755a9d12);
1048 mmio_write_32((0xf7128000 + 0x104), 0x1753b055);
1049 mmio_write_32((0xf7128000 + 0x108), 0x7401505f);
1050 mmio_write_32((0xf7128000 + 0x10c), 0x578ca244);
1051 mmio_write_32((0xf7128000 + 0x110), 0x10700000);
1052 mmio_write_32((0xf7128000 + 0x114), 0x13141306);
1053 mmio_write_32((0xf7128000 + 0x118), 0x44);
1054 do {
1055 data = mmio_read_32((0xf712c000 + 0x004));
1056 } while (data & 1);
1057 data = mmio_read_32((0xf712c000 + 0x008));
1058 if (data & 0x7fe) {
1059 NOTICE("fail to init ddr3 rank0\n");
1060 return;
1061 }
1062 ddrx_rdet();
1063 ddrx_wdet();
1064
1065 data = mmio_read_32((0xf712c000 + 0x048));
1066 data |= 1;
1067 mmio_write_32((0xf712c000 + 0x048), data);
1068 mmio_write_32((0xf712c000 + 0x004), 0x21);
1069 do {
1070 data = mmio_read_32((0xf712c000 + 0x004));
1071 } while (data & 1);
1072
1073 data = mmio_read_32((0xf712c000 + 0x008));
1074 if (data & 0x7fe)
1075 NOTICE("ddr3 rank1 init failure\n");
1076 else
1077 INFO("ddr3 rank1 init pass\n");
1078
1079 data = mmio_read_32((0xf712c000 + 0x048));
1080 data &= ~0xf;
1081 mmio_write_32((0xf712c000 + 0x048), data);
1082 INFO("succeed to set ddrc 800mhz\n");
1083 }
1084
ddrc_common_init(int freq)1085 static void ddrc_common_init(int freq)
1086 {
1087 unsigned int data;
1088
1089 mmio_write_32((0xf7120000 + 0x020), 0x1);
1090 mmio_write_32((0xf7120000 + 0x100), 0x1700);
1091 mmio_write_32((0xf7120000 + 0x104), 0x71040004);
1092 mmio_write_32((0xf7121400 + 0x104), 0xf);
1093 mmio_write_32((0xf7121800 + 0x104), 0xf);
1094 mmio_write_32((0xf7121c00 + 0x104), 0xf);
1095 mmio_write_32((0xf7122000 + 0x104), 0xf);
1096 mmio_write_32((0xf7128000 + 0x02c), 0x6);
1097 mmio_write_32((0xf7128000 + 0x020), 0x30003);
1098 mmio_write_32((0xf7128000 + 0x028), 0x310201);
1099 mmio_write_32((0xf712c000 + 0x1e4), 0xfe007600);
1100 mmio_write_32((0xf7128000 + 0x01c), 0xaf001);
1101
1102
1103 data = mmio_read_32((0xf7128000 + 0x280));
1104 data |= 1 << 7;
1105 mmio_write_32((0xf7128000 + 0x280), data);
1106 mmio_write_32((0xf7128000 + 0x244), 0x3);
1107
1108 if (freq == DDR_FREQ_800M)
1109 mmio_write_32((0xf7128000 + 0x240), 167 * (freq / 2) / 1024);
1110 else
1111 mmio_write_32((0xf7128000 + 0x240), 167 * freq / 1024);
1112
1113 data = mmio_read_32((0xf712c000 + 0x080));
1114 data &= 0xffff;
1115 data |= 0x4002000;
1116 mmio_write_32((0xf712c000 + 0x080), data);
1117 mmio_write_32((0xf7128000 + 0x000), 0x0);
1118 do {
1119 data = mmio_read_32((0xf7128000 + 0x294));
1120 } while (data & 1);
1121 mmio_write_32((0xf7128000 + 0x000), 0x2);
1122 }
1123
1124
dienum_det_and_rowcol_cfg(void)1125 static int dienum_det_and_rowcol_cfg(void)
1126 {
1127 unsigned int data;
1128
1129 mmio_write_32((0xf7128000 + 0x210), 0x87);
1130 mmio_write_32((0xf7128000 + 0x218), 0x10000);
1131 mmio_write_32((0xf7128000 + 0x00c), 0x1);
1132 do {
1133 data = mmio_read_32((0xf7128000 + 0x00c));
1134 } while (data & 1);
1135 data = mmio_read_32((0xf7128000 + 0x4a8)) & 0xfc;
1136 switch (data) {
1137 case 0x18:
1138 mmio_write_32((0xf7128000 + 0x060), 0x132);
1139 mmio_write_32((0xf7128000 + 0x064), 0x132);
1140 mmio_write_32((0xf7120000 + 0x100), 0x1600);
1141 mmio_write_32((0xf7120000 + 0x104), 0x71040004);
1142 mmio_write_32(MEMORY_AXI_DDR_CAPACITY_ADDR, 0x40000000);
1143 break;
1144 case 0x1c:
1145 mmio_write_32((0xf7128000 + 0x060), 0x142);
1146 mmio_write_32((0xf7128000 + 0x064), 0x142);
1147 mmio_write_32((0xf7120000 + 0x100), 0x1700);
1148 mmio_write_32((0xf7120000 + 0x104), 0x71040004);
1149 mmio_write_32(MEMORY_AXI_DDR_CAPACITY_ADDR, 0x80000000);
1150 break;
1151 case 0x58:
1152 mmio_write_32((0xf7128000 + 0x060), 0x133);
1153 mmio_write_32((0xf7128000 + 0x064), 0x133);
1154 mmio_write_32((0xf7120000 + 0x100), 0x1700);
1155 mmio_write_32((0xf7120000 + 0x104), 0x71040004);
1156 mmio_write_32(MEMORY_AXI_DDR_CAPACITY_ADDR, 0x80000000);
1157 break;
1158 default:
1159 mmio_write_32(MEMORY_AXI_DDR_CAPACITY_ADDR, 0x80000000);
1160 break;
1161 }
1162 if (!data)
1163 return -EINVAL;
1164 return 0;
1165 }
1166
detect_ddr_chip_info(void)1167 static int detect_ddr_chip_info(void)
1168 {
1169 unsigned int data, mr5, mr6, mr7;
1170
1171 mmio_write_32((0xf7128000 + 0x210), 0x57);
1172 mmio_write_32((0xf7128000 + 0x218), 0x10000);
1173 mmio_write_32((0xf7128000 + 0x00c), 0x1);
1174
1175 do {
1176 data = mmio_read_32((0xf7128000 + 0x00c));
1177 } while (data & 1);
1178
1179 data = mmio_read_32((0xf7128000 + 0x4a8));
1180 mr5 = data & 0xff;
1181 switch (mr5) {
1182 case 1:
1183 INFO("Samsung DDR\n");
1184 break;
1185 case 6:
1186 INFO("Hynix DDR\n");
1187 break;
1188 case 3:
1189 INFO("Elpida DDR\n");
1190 break;
1191 default:
1192 INFO("DDR from other vendors\n");
1193 break;
1194 }
1195
1196 mmio_write_32((0xf7128000 + 0x210), 0x67);
1197 mmio_write_32((0xf7128000 + 0x218), 0x10000);
1198 mmio_write_32((0xf7128000 + 0x00c), 0x1);
1199 do {
1200 data = mmio_read_32((0xf7128000 + 0x00c));
1201 } while (data & 1);
1202 data = mmio_read_32((0xf7128000 + 0x4a8));
1203 mr6 = data & 0xff;
1204 mmio_write_32((0xf7128000 + 0x210), 0x77);
1205 mmio_write_32((0xf7128000 + 0x218), 0x10000);
1206 mmio_write_32((0xf7128000 + 0x00c), 0x1);
1207 do {
1208 data = mmio_read_32((0xf7128000 + 0x00c));
1209 } while (data & 1);
1210 data = mmio_read_32((0xf7128000 + 0x4a8));
1211 mr7 = data & 0xff;
1212 data = mr5 + (mr6 << 8) + (mr7 << 16);
1213 return data;
1214 }
1215
ddr_phy_reset(void)1216 void ddr_phy_reset(void)
1217 {
1218 mmio_write_32(0xf7030340, 0xa000);
1219 mmio_write_32(0xf7030344, 0xa000);
1220 }
1221
lpddrx_save_ddl_para_bypass(uint32_t * ddr_ddl_para,unsigned int index)1222 void lpddrx_save_ddl_para_bypass(uint32_t *ddr_ddl_para, unsigned int index)
1223 {
1224 uint32_t value;
1225 uint32_t cnt = index;
1226 uint32_t i;
1227
1228 for (i = 0; i < 4; i++) {
1229 value = mmio_read_32(0xf712c000 + 0x22c + i * 0x80);
1230 ddr_ddl_para[cnt++] = value;
1231 value = mmio_read_32(0xf712c000 + 0x23c + i * 0x80);
1232 ddr_ddl_para[cnt++] = value;
1233 value = mmio_read_32(0xf712c000 + 0x240 + i * 0x80);
1234 ddr_ddl_para[cnt++] = value;
1235 value = mmio_read_32(0xf712c000 + 0x640 + i * 0x80);
1236 ddr_ddl_para[cnt++] = value;
1237 }
1238 }
1239
lpddrx_save_ddl_para_mission(uint32_t * ddr_ddl_para,unsigned int index)1240 void lpddrx_save_ddl_para_mission(uint32_t *ddr_ddl_para, unsigned int index)
1241 {
1242 uint32_t value;
1243 uint32_t cnt = index;
1244 uint32_t i;
1245
1246 value = mmio_read_32(0xf712c000 + 0x140);
1247 ddr_ddl_para[cnt++] = value;
1248 value = mmio_read_32(0xf712c000 + 0x144);
1249 ddr_ddl_para[cnt++] = value;
1250 value = mmio_read_32(0xf712c000 + 0x148);
1251 ddr_ddl_para[cnt++] = value;
1252 value = mmio_read_32(0xf712c000 + 0x14c);
1253 ddr_ddl_para[cnt++] = value;
1254 value = mmio_read_32(0xf712c000 + 0x150);
1255 ddr_ddl_para[cnt++] = value;
1256 value = mmio_read_32(0xf712c000 + 0x1d4);
1257 ddr_ddl_para[cnt++] = value;
1258 for (i = 0; i < 4; i++) {
1259 value = mmio_read_32(0xf712c000 + 0x210 + i * 0x80);
1260 ddr_ddl_para[cnt++] = value;
1261 value = mmio_read_32(0xf712c000 + 0x214 + i * 0x80);
1262 ddr_ddl_para[cnt++] = value;
1263 value = mmio_read_32(0xf712c000 + 0x218 + i * 0x80);
1264 ddr_ddl_para[cnt++] = value;
1265 value = mmio_read_32(0xf712c000 + 0x21c + i * 0x80);
1266 ddr_ddl_para[cnt++] = value;
1267 value = mmio_read_32(0xf712c000 + 0x220 + i * 0x80);
1268 ddr_ddl_para[cnt++] = value;
1269 value = mmio_read_32(0xf712c000 + 0x224 + i * 0x80);
1270 ddr_ddl_para[cnt++] = value;
1271 value = mmio_read_32(0xf712c000 + 0x228 + i * 0x80);
1272 ddr_ddl_para[cnt++] = value;
1273 value = mmio_read_32(0xf712c000 + 0x22c + i * 0x80);
1274 ddr_ddl_para[cnt++] = value;
1275 value = mmio_read_32(0xf712c000 + 0x230 + i * 0x80);
1276 ddr_ddl_para[cnt++] = value;
1277 value = mmio_read_32(0xf712c000 + 0x234 + i * 0x80);
1278 ddr_ddl_para[cnt++] = value;
1279 value = mmio_read_32(0xf712c000 + 0x238 + i * 0x80);
1280 ddr_ddl_para[cnt++] = value;
1281 value = mmio_read_32(0xf712c000 + 0x23c + i * 0x80);
1282 ddr_ddl_para[cnt++] = value;
1283 value = mmio_read_32(0xf712c000 + 0x240 + i * 0x80);
1284 ddr_ddl_para[cnt++] = value;
1285 value = mmio_read_32(0xf712c000 + 0x640 + i * 0x80);
1286 ddr_ddl_para[cnt++] = value;
1287 }
1288 value = mmio_read_32(0xf712c000 + 0x168);
1289 ddr_ddl_para[cnt++] = value;
1290 value = mmio_read_32(0xf712c000 + 0x24c + 0 * 0x80);
1291 ddr_ddl_para[cnt++] = value;
1292 value = mmio_read_32(0xf712c000 + 0x24c + 2 * 0x80);
1293 ddr_ddl_para[cnt++] = value;
1294 }
1295
lpddr3_freq_init(int freq)1296 int lpddr3_freq_init(int freq)
1297 {
1298 set_ddrc_150mhz();
1299 lpddrx_save_ddl_para_bypass((uint32_t *)MEMORY_AXI_DDR_DDL_ADDR, 0);
1300 if (freq > DDR_FREQ_150M) {
1301 ddr_phy_reset();
1302 set_ddrc_266mhz();
1303 lpddrx_save_ddl_para_bypass((uint32_t *)MEMORY_AXI_DDR_DDL_ADDR,
1304 16);
1305 }
1306 if (freq > DDR_FREQ_266M) {
1307 ddr_phy_reset();
1308 set_ddrc_400mhz();
1309 lpddrx_save_ddl_para_bypass((uint32_t *)MEMORY_AXI_DDR_DDL_ADDR,
1310 16 * 2);
1311 }
1312 if (freq > DDR_FREQ_400M) {
1313 ddr_phy_reset();
1314 set_ddrc_533mhz();
1315 lpddrx_save_ddl_para_mission((uint32_t *)MEMORY_AXI_DDR_DDL_ADDR,
1316 16 * 3);
1317 }
1318 if (freq > DDR_FREQ_533M) {
1319 ddr_phy_reset();
1320 set_ddrc_800mhz();
1321 lpddrx_save_ddl_para_mission((uint32_t *)MEMORY_AXI_DDR_DDL_ADDR,
1322 16 * 3 + 61);
1323 }
1324 return 0;
1325 }
1326
init_ddr(int freq)1327 static void init_ddr(int freq)
1328 {
1329 unsigned int data;
1330 int ret;
1331
1332
1333 data = mmio_read_32((0xf7032000 + 0x030));
1334 data |= 1;
1335 mmio_write_32((0xf7032000 + 0x030), data);
1336 data = mmio_read_32((0xf7032000 + 0x010));
1337 data |= 1;
1338 mmio_write_32((0xf7032000 + 0x010), data);
1339
1340 udelay(300);
1341 do {
1342 data = mmio_read_32((0xf7032000 + 0x030));
1343 data &= 3 << 28;
1344 } while (data != (3 << 28));
1345 do {
1346 data = mmio_read_32((0xf7032000 + 0x010));
1347 data &= 3 << 28;
1348 } while (data != (3 << 28));
1349
1350 ret = lpddr3_freq_init(freq);
1351 if (ret)
1352 return;
1353 }
1354
init_ddrc_qos(void)1355 static void init_ddrc_qos(void)
1356 {
1357 unsigned int port, data;
1358
1359 mmio_write_32((0xf7124000 + 0x088), 1);
1360
1361 port = 0;
1362 mmio_write_32((0xf7120000 + 0x200 + port * 0x10), 0x1210);
1363 mmio_write_32((0xf7120000 + 0x204 + port * 0x10), 0x11111111);
1364 mmio_write_32((0xf7120000 + 0x208 + port * 0x10), 0x11111111);
1365 mmio_write_32((0xf7120000 + 0x400 + 0 * 0x10), 0x001d0007);
1366
1367 for (port = 3; port <= 4; port++) {
1368 mmio_write_32((0xf7120000 + 0x200 + port * 0x10), 0x1210);
1369 mmio_write_32((0xf7120000 + 0x204 + port * 0x10), 0x77777777);
1370 mmio_write_32((0xf7120000 + 0x208 + port * 0x10), 0x77777777);
1371 }
1372
1373 port = 1;
1374 mmio_write_32((0xf7120000 + 0x200 + port * 0x10), 0x30000);
1375 mmio_write_32((0xf7120000 + 0x204 + port * 0x10), 0x1234567);
1376 mmio_write_32((0xf7120000 + 0x208 + port * 0x10), 0x1234567);
1377
1378 mmio_write_32((0xf7124000 + 0x1f0), 0);
1379 mmio_write_32((0xf7124000 + 0x0bc), 0x3020100);
1380 mmio_write_32((0xf7124000 + 0x0d0), 0x3020100);
1381 mmio_write_32((0xf7124000 + 0x1f4), 0x01000100);
1382 mmio_write_32((0xf7124000 + 0x08c + 0 * 4), 0xd0670402);
1383 mmio_write_32((0xf7124000 + 0x068 + 0 * 4), 0x31);
1384 mmio_write_32((0xf7124000 + 0x000), 0x7);
1385
1386 data = mmio_read_32((0xf7124000 + 0x09c));
1387 data &= ~0xff0000;
1388 data |= 0x400000;
1389 mmio_write_32((0xf7124000 + 0x09c), data);
1390 data = mmio_read_32((0xf7124000 + 0x0ac));
1391 data &= ~0xff0000;
1392 data |= 0x400000;
1393 mmio_write_32((0xf7124000 + 0x0ac), data);
1394 port = 2;
1395 mmio_write_32((0xf7120000 + 0x200 + port * 0x10), 0x30000);
1396 mmio_write_32((0xf7120000 + 0x204 + port * 0x10), 0x1234567);
1397 mmio_write_32((0xf7120000 + 0x208 + port * 0x10), 0x1234567);
1398
1399
1400 mmio_write_32((0xf7124000 + 0x09c), 0xff7fff);
1401 mmio_write_32((0xf7124000 + 0x0a0), 0xff);
1402 mmio_write_32((0xf7124000 + 0x0ac), 0xff7fff);
1403 mmio_write_32((0xf7124000 + 0x0b0), 0xff);
1404 mmio_write_32((0xf7124000 + 0x0bc), 0x3020100);
1405 mmio_write_32((0xf7124000 + 0x0d0), 0x3020100);
1406 }
1407
hikey_ddr_init(unsigned int ddr_freq)1408 void hikey_ddr_init(unsigned int ddr_freq)
1409 {
1410 uint32_t data;
1411
1412 assert((ddr_freq == DDR_FREQ_150M) || (ddr_freq == DDR_FREQ_266M) ||
1413 (ddr_freq == DDR_FREQ_400M) || (ddr_freq == DDR_FREQ_533M) ||
1414 (ddr_freq == DDR_FREQ_800M));
1415 init_pll();
1416 init_freq();
1417
1418 init_ddr(ddr_freq);
1419
1420 ddrc_common_init(ddr_freq);
1421 dienum_det_and_rowcol_cfg();
1422 detect_ddr_chip_info();
1423
1424 if ((ddr_freq == DDR_FREQ_400M) || (ddr_freq == DDR_FREQ_800M)) {
1425 data = mmio_read_32(0xf7032000 + 0x010);
1426 data &= ~0x1;
1427 mmio_write_32(0xf7032000 + 0x010, data);
1428 } else if ((ddr_freq == DDR_FREQ_266M) || (ddr_freq == DDR_FREQ_533M)) {
1429 data = mmio_read_32(0xf7032000 + 0x030);
1430 data &= ~0x1;
1431 mmio_write_32(0xf7032000 + 0x030, data);
1432 } else {
1433 data = mmio_read_32(0xf7032000 + 0x010);
1434 data &= ~0x1;
1435 mmio_write_32(0xf7032000 + 0x010, data);
1436 data = mmio_read_32(0xf7032000 + 0x030);
1437 data &= ~0x1;
1438 mmio_write_32(0xf7032000 + 0x030, data);
1439 }
1440 dsb();
1441 isb();
1442
1443 /*
1444 * Test memory access. Do not use address 0x0 because the compiler
1445 * may assume it is not a valid address and generate incorrect code
1446 * (GCC 4.9.1 without -fno-delete-null-pointer-checks for instance).
1447 */
1448 mmio_write_32(0x4, 0xa5a55a5a);
1449 INFO("ddr test value:0x%x\n", mmio_read_32(0x4));
1450 init_ddrc_qos();
1451 }
1452