1 /* 2 * Copyright 2008, 2010-2014 Freescale Semiconductor, Inc. 3 * 4 * SPDX-License-Identifier: GPL-2.0+ 5 */ 6 7 #include <common.h> 8 #include <hwconfig.h> 9 #include <fsl_ddr_sdram.h> 10 11 #include <fsl_ddr.h> 12 13 /* 14 * Use our own stack based buffer before relocation to allow accessing longer 15 * hwconfig strings that might be in the environment before we've relocated. 16 * This is pretty fragile on both the use of stack and if the buffer is big 17 * enough. However we will get a warning from getenv_f for the later. 18 */ 19 20 /* Board-specific functions defined in each board's ddr.c */ 21 extern void fsl_ddr_board_options(memctl_options_t *popts, 22 dimm_params_t *pdimm, 23 unsigned int ctrl_num); 24 25 struct dynamic_odt { 26 unsigned int odt_rd_cfg; 27 unsigned int odt_wr_cfg; 28 unsigned int odt_rtt_norm; 29 unsigned int odt_rtt_wr; 30 }; 31 32 #ifdef CONFIG_SYS_FSL_DDR4 33 /* Quad rank is not verified yet due availability. 34 * Replacing 20 OHM with 34 OHM since DDR4 doesn't have 20 OHM option 35 */ 36 static const struct dynamic_odt single_Q[4] = { 37 { /* cs0 */ 38 FSL_DDR_ODT_NEVER, 39 FSL_DDR_ODT_CS_AND_OTHER_DIMM, 40 DDR4_RTT_34_OHM, /* unverified */ 41 DDR4_RTT_120_OHM 42 }, 43 { /* cs1 */ 44 FSL_DDR_ODT_NEVER, 45 FSL_DDR_ODT_NEVER, 46 DDR4_RTT_OFF, 47 DDR4_RTT_120_OHM 48 }, 49 { /* cs2 */ 50 FSL_DDR_ODT_NEVER, 51 FSL_DDR_ODT_CS_AND_OTHER_DIMM, 52 DDR4_RTT_34_OHM, 53 DDR4_RTT_120_OHM 54 }, 55 { /* cs3 */ 56 FSL_DDR_ODT_NEVER, 57 FSL_DDR_ODT_NEVER, /* tied high */ 58 DDR4_RTT_OFF, 59 DDR4_RTT_120_OHM 60 } 61 }; 62 63 static const struct dynamic_odt single_D[4] = { 64 { /* cs0 */ 65 FSL_DDR_ODT_NEVER, 66 FSL_DDR_ODT_ALL, 67 DDR4_RTT_40_OHM, 68 DDR4_RTT_OFF 69 }, 70 { /* cs1 */ 71 FSL_DDR_ODT_NEVER, 72 FSL_DDR_ODT_NEVER, 73 DDR4_RTT_OFF, 74 DDR4_RTT_OFF 75 }, 76 {0, 0, 0, 0}, 77 {0, 0, 0, 0} 78 }; 79 80 static const struct dynamic_odt single_S[4] = { 81 { /* cs0 */ 82 FSL_DDR_ODT_NEVER, 83 FSL_DDR_ODT_ALL, 84 DDR4_RTT_40_OHM, 85 DDR4_RTT_OFF 86 }, 87 {0, 0, 0, 0}, 88 {0, 0, 0, 0}, 89 {0, 0, 0, 0}, 90 }; 91 92 static const struct dynamic_odt dual_DD[4] = { 93 { /* cs0 */ 94 FSL_DDR_ODT_NEVER, 95 FSL_DDR_ODT_SAME_DIMM, 96 DDR4_RTT_120_OHM, 97 DDR4_RTT_OFF 98 }, 99 { /* cs1 */ 100 FSL_DDR_ODT_OTHER_DIMM, 101 FSL_DDR_ODT_OTHER_DIMM, 102 DDR4_RTT_34_OHM, 103 DDR4_RTT_OFF 104 }, 105 { /* cs2 */ 106 FSL_DDR_ODT_NEVER, 107 FSL_DDR_ODT_SAME_DIMM, 108 DDR4_RTT_120_OHM, 109 DDR4_RTT_OFF 110 }, 111 { /* cs3 */ 112 FSL_DDR_ODT_OTHER_DIMM, 113 FSL_DDR_ODT_OTHER_DIMM, 114 DDR4_RTT_34_OHM, 115 DDR4_RTT_OFF 116 } 117 }; 118 119 static const struct dynamic_odt dual_DS[4] = { 120 { /* cs0 */ 121 FSL_DDR_ODT_NEVER, 122 FSL_DDR_ODT_SAME_DIMM, 123 DDR4_RTT_120_OHM, 124 DDR4_RTT_OFF 125 }, 126 { /* cs1 */ 127 FSL_DDR_ODT_OTHER_DIMM, 128 FSL_DDR_ODT_OTHER_DIMM, 129 DDR4_RTT_34_OHM, 130 DDR4_RTT_OFF 131 }, 132 { /* cs2 */ 133 FSL_DDR_ODT_OTHER_DIMM, 134 FSL_DDR_ODT_ALL, 135 DDR4_RTT_34_OHM, 136 DDR4_RTT_120_OHM 137 }, 138 {0, 0, 0, 0} 139 }; 140 static const struct dynamic_odt dual_SD[4] = { 141 { /* cs0 */ 142 FSL_DDR_ODT_OTHER_DIMM, 143 FSL_DDR_ODT_ALL, 144 DDR4_RTT_34_OHM, 145 DDR4_RTT_120_OHM 146 }, 147 {0, 0, 0, 0}, 148 { /* cs2 */ 149 FSL_DDR_ODT_NEVER, 150 FSL_DDR_ODT_SAME_DIMM, 151 DDR4_RTT_120_OHM, 152 DDR4_RTT_OFF 153 }, 154 { /* cs3 */ 155 FSL_DDR_ODT_OTHER_DIMM, 156 FSL_DDR_ODT_OTHER_DIMM, 157 DDR4_RTT_34_OHM, 158 DDR4_RTT_OFF 159 } 160 }; 161 162 static const struct dynamic_odt dual_SS[4] = { 163 { /* cs0 */ 164 FSL_DDR_ODT_OTHER_DIMM, 165 FSL_DDR_ODT_ALL, 166 DDR4_RTT_34_OHM, 167 DDR4_RTT_120_OHM 168 }, 169 {0, 0, 0, 0}, 170 { /* cs2 */ 171 FSL_DDR_ODT_OTHER_DIMM, 172 FSL_DDR_ODT_ALL, 173 DDR4_RTT_34_OHM, 174 DDR4_RTT_120_OHM 175 }, 176 {0, 0, 0, 0} 177 }; 178 179 static const struct dynamic_odt dual_D0[4] = { 180 { /* cs0 */ 181 FSL_DDR_ODT_NEVER, 182 FSL_DDR_ODT_SAME_DIMM, 183 DDR4_RTT_40_OHM, 184 DDR4_RTT_OFF 185 }, 186 { /* cs1 */ 187 FSL_DDR_ODT_NEVER, 188 FSL_DDR_ODT_NEVER, 189 DDR4_RTT_OFF, 190 DDR4_RTT_OFF 191 }, 192 {0, 0, 0, 0}, 193 {0, 0, 0, 0} 194 }; 195 196 static const struct dynamic_odt dual_0D[4] = { 197 {0, 0, 0, 0}, 198 {0, 0, 0, 0}, 199 { /* cs2 */ 200 FSL_DDR_ODT_NEVER, 201 FSL_DDR_ODT_SAME_DIMM, 202 DDR4_RTT_40_OHM, 203 DDR4_RTT_OFF 204 }, 205 { /* cs3 */ 206 FSL_DDR_ODT_NEVER, 207 FSL_DDR_ODT_NEVER, 208 DDR4_RTT_OFF, 209 DDR4_RTT_OFF 210 } 211 }; 212 213 static const struct dynamic_odt dual_S0[4] = { 214 { /* cs0 */ 215 FSL_DDR_ODT_NEVER, 216 FSL_DDR_ODT_CS, 217 DDR4_RTT_40_OHM, 218 DDR4_RTT_OFF 219 }, 220 {0, 0, 0, 0}, 221 {0, 0, 0, 0}, 222 {0, 0, 0, 0} 223 224 }; 225 226 static const struct dynamic_odt dual_0S[4] = { 227 {0, 0, 0, 0}, 228 {0, 0, 0, 0}, 229 { /* cs2 */ 230 FSL_DDR_ODT_NEVER, 231 FSL_DDR_ODT_CS, 232 DDR4_RTT_40_OHM, 233 DDR4_RTT_OFF 234 }, 235 {0, 0, 0, 0} 236 237 }; 238 239 static const struct dynamic_odt odt_unknown[4] = { 240 { /* cs0 */ 241 FSL_DDR_ODT_NEVER, 242 FSL_DDR_ODT_CS, 243 DDR4_RTT_120_OHM, 244 DDR4_RTT_OFF 245 }, 246 { /* cs1 */ 247 FSL_DDR_ODT_NEVER, 248 FSL_DDR_ODT_CS, 249 DDR4_RTT_120_OHM, 250 DDR4_RTT_OFF 251 }, 252 { /* cs2 */ 253 FSL_DDR_ODT_NEVER, 254 FSL_DDR_ODT_CS, 255 DDR4_RTT_120_OHM, 256 DDR4_RTT_OFF 257 }, 258 { /* cs3 */ 259 FSL_DDR_ODT_NEVER, 260 FSL_DDR_ODT_CS, 261 DDR4_RTT_120_OHM, 262 DDR4_RTT_OFF 263 } 264 }; 265 #elif defined(CONFIG_SYS_FSL_DDR3) 266 static const struct dynamic_odt single_Q[4] = { 267 { /* cs0 */ 268 FSL_DDR_ODT_NEVER, 269 FSL_DDR_ODT_CS_AND_OTHER_DIMM, 270 DDR3_RTT_20_OHM, 271 DDR3_RTT_120_OHM 272 }, 273 { /* cs1 */ 274 FSL_DDR_ODT_NEVER, 275 FSL_DDR_ODT_NEVER, /* tied high */ 276 DDR3_RTT_OFF, 277 DDR3_RTT_120_OHM 278 }, 279 { /* cs2 */ 280 FSL_DDR_ODT_NEVER, 281 FSL_DDR_ODT_CS_AND_OTHER_DIMM, 282 DDR3_RTT_20_OHM, 283 DDR3_RTT_120_OHM 284 }, 285 { /* cs3 */ 286 FSL_DDR_ODT_NEVER, 287 FSL_DDR_ODT_NEVER, /* tied high */ 288 DDR3_RTT_OFF, 289 DDR3_RTT_120_OHM 290 } 291 }; 292 293 static const struct dynamic_odt single_D[4] = { 294 { /* cs0 */ 295 FSL_DDR_ODT_NEVER, 296 FSL_DDR_ODT_ALL, 297 DDR3_RTT_40_OHM, 298 DDR3_RTT_OFF 299 }, 300 { /* cs1 */ 301 FSL_DDR_ODT_NEVER, 302 FSL_DDR_ODT_NEVER, 303 DDR3_RTT_OFF, 304 DDR3_RTT_OFF 305 }, 306 {0, 0, 0, 0}, 307 {0, 0, 0, 0} 308 }; 309 310 static const struct dynamic_odt single_S[4] = { 311 { /* cs0 */ 312 FSL_DDR_ODT_NEVER, 313 FSL_DDR_ODT_ALL, 314 DDR3_RTT_40_OHM, 315 DDR3_RTT_OFF 316 }, 317 {0, 0, 0, 0}, 318 {0, 0, 0, 0}, 319 {0, 0, 0, 0}, 320 }; 321 322 static const struct dynamic_odt dual_DD[4] = { 323 { /* cs0 */ 324 FSL_DDR_ODT_NEVER, 325 FSL_DDR_ODT_SAME_DIMM, 326 DDR3_RTT_120_OHM, 327 DDR3_RTT_OFF 328 }, 329 { /* cs1 */ 330 FSL_DDR_ODT_OTHER_DIMM, 331 FSL_DDR_ODT_OTHER_DIMM, 332 DDR3_RTT_30_OHM, 333 DDR3_RTT_OFF 334 }, 335 { /* cs2 */ 336 FSL_DDR_ODT_NEVER, 337 FSL_DDR_ODT_SAME_DIMM, 338 DDR3_RTT_120_OHM, 339 DDR3_RTT_OFF 340 }, 341 { /* cs3 */ 342 FSL_DDR_ODT_OTHER_DIMM, 343 FSL_DDR_ODT_OTHER_DIMM, 344 DDR3_RTT_30_OHM, 345 DDR3_RTT_OFF 346 } 347 }; 348 349 static const struct dynamic_odt dual_DS[4] = { 350 { /* cs0 */ 351 FSL_DDR_ODT_NEVER, 352 FSL_DDR_ODT_SAME_DIMM, 353 DDR3_RTT_120_OHM, 354 DDR3_RTT_OFF 355 }, 356 { /* cs1 */ 357 FSL_DDR_ODT_OTHER_DIMM, 358 FSL_DDR_ODT_OTHER_DIMM, 359 DDR3_RTT_30_OHM, 360 DDR3_RTT_OFF 361 }, 362 { /* cs2 */ 363 FSL_DDR_ODT_OTHER_DIMM, 364 FSL_DDR_ODT_ALL, 365 DDR3_RTT_20_OHM, 366 DDR3_RTT_120_OHM 367 }, 368 {0, 0, 0, 0} 369 }; 370 static const struct dynamic_odt dual_SD[4] = { 371 { /* cs0 */ 372 FSL_DDR_ODT_OTHER_DIMM, 373 FSL_DDR_ODT_ALL, 374 DDR3_RTT_20_OHM, 375 DDR3_RTT_120_OHM 376 }, 377 {0, 0, 0, 0}, 378 { /* cs2 */ 379 FSL_DDR_ODT_NEVER, 380 FSL_DDR_ODT_SAME_DIMM, 381 DDR3_RTT_120_OHM, 382 DDR3_RTT_OFF 383 }, 384 { /* cs3 */ 385 FSL_DDR_ODT_OTHER_DIMM, 386 FSL_DDR_ODT_OTHER_DIMM, 387 DDR3_RTT_20_OHM, 388 DDR3_RTT_OFF 389 } 390 }; 391 392 static const struct dynamic_odt dual_SS[4] = { 393 { /* cs0 */ 394 FSL_DDR_ODT_OTHER_DIMM, 395 FSL_DDR_ODT_ALL, 396 DDR3_RTT_30_OHM, 397 DDR3_RTT_120_OHM 398 }, 399 {0, 0, 0, 0}, 400 { /* cs2 */ 401 FSL_DDR_ODT_OTHER_DIMM, 402 FSL_DDR_ODT_ALL, 403 DDR3_RTT_30_OHM, 404 DDR3_RTT_120_OHM 405 }, 406 {0, 0, 0, 0} 407 }; 408 409 static const struct dynamic_odt dual_D0[4] = { 410 { /* cs0 */ 411 FSL_DDR_ODT_NEVER, 412 FSL_DDR_ODT_SAME_DIMM, 413 DDR3_RTT_40_OHM, 414 DDR3_RTT_OFF 415 }, 416 { /* cs1 */ 417 FSL_DDR_ODT_NEVER, 418 FSL_DDR_ODT_NEVER, 419 DDR3_RTT_OFF, 420 DDR3_RTT_OFF 421 }, 422 {0, 0, 0, 0}, 423 {0, 0, 0, 0} 424 }; 425 426 static const struct dynamic_odt dual_0D[4] = { 427 {0, 0, 0, 0}, 428 {0, 0, 0, 0}, 429 { /* cs2 */ 430 FSL_DDR_ODT_NEVER, 431 FSL_DDR_ODT_SAME_DIMM, 432 DDR3_RTT_40_OHM, 433 DDR3_RTT_OFF 434 }, 435 { /* cs3 */ 436 FSL_DDR_ODT_NEVER, 437 FSL_DDR_ODT_NEVER, 438 DDR3_RTT_OFF, 439 DDR3_RTT_OFF 440 } 441 }; 442 443 static const struct dynamic_odt dual_S0[4] = { 444 { /* cs0 */ 445 FSL_DDR_ODT_NEVER, 446 FSL_DDR_ODT_CS, 447 DDR3_RTT_40_OHM, 448 DDR3_RTT_OFF 449 }, 450 {0, 0, 0, 0}, 451 {0, 0, 0, 0}, 452 {0, 0, 0, 0} 453 454 }; 455 456 static const struct dynamic_odt dual_0S[4] = { 457 {0, 0, 0, 0}, 458 {0, 0, 0, 0}, 459 { /* cs2 */ 460 FSL_DDR_ODT_NEVER, 461 FSL_DDR_ODT_CS, 462 DDR3_RTT_40_OHM, 463 DDR3_RTT_OFF 464 }, 465 {0, 0, 0, 0} 466 467 }; 468 469 static const struct dynamic_odt odt_unknown[4] = { 470 { /* cs0 */ 471 FSL_DDR_ODT_NEVER, 472 FSL_DDR_ODT_CS, 473 DDR3_RTT_120_OHM, 474 DDR3_RTT_OFF 475 }, 476 { /* cs1 */ 477 FSL_DDR_ODT_NEVER, 478 FSL_DDR_ODT_CS, 479 DDR3_RTT_120_OHM, 480 DDR3_RTT_OFF 481 }, 482 { /* cs2 */ 483 FSL_DDR_ODT_NEVER, 484 FSL_DDR_ODT_CS, 485 DDR3_RTT_120_OHM, 486 DDR3_RTT_OFF 487 }, 488 { /* cs3 */ 489 FSL_DDR_ODT_NEVER, 490 FSL_DDR_ODT_CS, 491 DDR3_RTT_120_OHM, 492 DDR3_RTT_OFF 493 } 494 }; 495 #else /* CONFIG_SYS_FSL_DDR3 */ 496 static const struct dynamic_odt single_Q[4] = { 497 {0, 0, 0, 0}, 498 {0, 0, 0, 0}, 499 {0, 0, 0, 0}, 500 {0, 0, 0, 0} 501 }; 502 503 static const struct dynamic_odt single_D[4] = { 504 { /* cs0 */ 505 FSL_DDR_ODT_NEVER, 506 FSL_DDR_ODT_ALL, 507 DDR2_RTT_150_OHM, 508 DDR2_RTT_OFF 509 }, 510 { /* cs1 */ 511 FSL_DDR_ODT_NEVER, 512 FSL_DDR_ODT_NEVER, 513 DDR2_RTT_OFF, 514 DDR2_RTT_OFF 515 }, 516 {0, 0, 0, 0}, 517 {0, 0, 0, 0} 518 }; 519 520 static const struct dynamic_odt single_S[4] = { 521 { /* cs0 */ 522 FSL_DDR_ODT_NEVER, 523 FSL_DDR_ODT_ALL, 524 DDR2_RTT_150_OHM, 525 DDR2_RTT_OFF 526 }, 527 {0, 0, 0, 0}, 528 {0, 0, 0, 0}, 529 {0, 0, 0, 0}, 530 }; 531 532 static const struct dynamic_odt dual_DD[4] = { 533 { /* cs0 */ 534 FSL_DDR_ODT_OTHER_DIMM, 535 FSL_DDR_ODT_OTHER_DIMM, 536 DDR2_RTT_75_OHM, 537 DDR2_RTT_OFF 538 }, 539 { /* cs1 */ 540 FSL_DDR_ODT_NEVER, 541 FSL_DDR_ODT_NEVER, 542 DDR2_RTT_OFF, 543 DDR2_RTT_OFF 544 }, 545 { /* cs2 */ 546 FSL_DDR_ODT_OTHER_DIMM, 547 FSL_DDR_ODT_OTHER_DIMM, 548 DDR2_RTT_75_OHM, 549 DDR2_RTT_OFF 550 }, 551 { /* cs3 */ 552 FSL_DDR_ODT_NEVER, 553 FSL_DDR_ODT_NEVER, 554 DDR2_RTT_OFF, 555 DDR2_RTT_OFF 556 } 557 }; 558 559 static const struct dynamic_odt dual_DS[4] = { 560 { /* cs0 */ 561 FSL_DDR_ODT_OTHER_DIMM, 562 FSL_DDR_ODT_OTHER_DIMM, 563 DDR2_RTT_75_OHM, 564 DDR2_RTT_OFF 565 }, 566 { /* cs1 */ 567 FSL_DDR_ODT_NEVER, 568 FSL_DDR_ODT_NEVER, 569 DDR2_RTT_OFF, 570 DDR2_RTT_OFF 571 }, 572 { /* cs2 */ 573 FSL_DDR_ODT_OTHER_DIMM, 574 FSL_DDR_ODT_OTHER_DIMM, 575 DDR2_RTT_75_OHM, 576 DDR2_RTT_OFF 577 }, 578 {0, 0, 0, 0} 579 }; 580 581 static const struct dynamic_odt dual_SD[4] = { 582 { /* cs0 */ 583 FSL_DDR_ODT_OTHER_DIMM, 584 FSL_DDR_ODT_OTHER_DIMM, 585 DDR2_RTT_75_OHM, 586 DDR2_RTT_OFF 587 }, 588 {0, 0, 0, 0}, 589 { /* cs2 */ 590 FSL_DDR_ODT_OTHER_DIMM, 591 FSL_DDR_ODT_OTHER_DIMM, 592 DDR2_RTT_75_OHM, 593 DDR2_RTT_OFF 594 }, 595 { /* cs3 */ 596 FSL_DDR_ODT_NEVER, 597 FSL_DDR_ODT_NEVER, 598 DDR2_RTT_OFF, 599 DDR2_RTT_OFF 600 } 601 }; 602 603 static const struct dynamic_odt dual_SS[4] = { 604 { /* cs0 */ 605 FSL_DDR_ODT_OTHER_DIMM, 606 FSL_DDR_ODT_OTHER_DIMM, 607 DDR2_RTT_75_OHM, 608 DDR2_RTT_OFF 609 }, 610 {0, 0, 0, 0}, 611 { /* cs2 */ 612 FSL_DDR_ODT_OTHER_DIMM, 613 FSL_DDR_ODT_OTHER_DIMM, 614 DDR2_RTT_75_OHM, 615 DDR2_RTT_OFF 616 }, 617 {0, 0, 0, 0} 618 }; 619 620 static const struct dynamic_odt dual_D0[4] = { 621 { /* cs0 */ 622 FSL_DDR_ODT_NEVER, 623 FSL_DDR_ODT_ALL, 624 DDR2_RTT_150_OHM, 625 DDR2_RTT_OFF 626 }, 627 { /* cs1 */ 628 FSL_DDR_ODT_NEVER, 629 FSL_DDR_ODT_NEVER, 630 DDR2_RTT_OFF, 631 DDR2_RTT_OFF 632 }, 633 {0, 0, 0, 0}, 634 {0, 0, 0, 0} 635 }; 636 637 static const struct dynamic_odt dual_0D[4] = { 638 {0, 0, 0, 0}, 639 {0, 0, 0, 0}, 640 { /* cs2 */ 641 FSL_DDR_ODT_NEVER, 642 FSL_DDR_ODT_ALL, 643 DDR2_RTT_150_OHM, 644 DDR2_RTT_OFF 645 }, 646 { /* cs3 */ 647 FSL_DDR_ODT_NEVER, 648 FSL_DDR_ODT_NEVER, 649 DDR2_RTT_OFF, 650 DDR2_RTT_OFF 651 } 652 }; 653 654 static const struct dynamic_odt dual_S0[4] = { 655 { /* cs0 */ 656 FSL_DDR_ODT_NEVER, 657 FSL_DDR_ODT_CS, 658 DDR2_RTT_150_OHM, 659 DDR2_RTT_OFF 660 }, 661 {0, 0, 0, 0}, 662 {0, 0, 0, 0}, 663 {0, 0, 0, 0} 664 665 }; 666 667 static const struct dynamic_odt dual_0S[4] = { 668 {0, 0, 0, 0}, 669 {0, 0, 0, 0}, 670 { /* cs2 */ 671 FSL_DDR_ODT_NEVER, 672 FSL_DDR_ODT_CS, 673 DDR2_RTT_150_OHM, 674 DDR2_RTT_OFF 675 }, 676 {0, 0, 0, 0} 677 678 }; 679 680 static const struct dynamic_odt odt_unknown[4] = { 681 { /* cs0 */ 682 FSL_DDR_ODT_NEVER, 683 FSL_DDR_ODT_CS, 684 DDR2_RTT_75_OHM, 685 DDR2_RTT_OFF 686 }, 687 { /* cs1 */ 688 FSL_DDR_ODT_NEVER, 689 FSL_DDR_ODT_NEVER, 690 DDR2_RTT_OFF, 691 DDR2_RTT_OFF 692 }, 693 { /* cs2 */ 694 FSL_DDR_ODT_NEVER, 695 FSL_DDR_ODT_CS, 696 DDR2_RTT_75_OHM, 697 DDR2_RTT_OFF 698 }, 699 { /* cs3 */ 700 FSL_DDR_ODT_NEVER, 701 FSL_DDR_ODT_NEVER, 702 DDR2_RTT_OFF, 703 DDR2_RTT_OFF 704 } 705 }; 706 #endif 707 708 /* 709 * Automatically seleect bank interleaving mode based on DIMMs 710 * in this order: cs0_cs1_cs2_cs3, cs0_cs1, null. 711 * This function only deal with one or two slots per controller. 712 */ 713 static inline unsigned int auto_bank_intlv(dimm_params_t *pdimm) 714 { 715 #if (CONFIG_DIMM_SLOTS_PER_CTLR == 1) 716 if (pdimm[0].n_ranks == 4) 717 return FSL_DDR_CS0_CS1_CS2_CS3; 718 else if (pdimm[0].n_ranks == 2) 719 return FSL_DDR_CS0_CS1; 720 #elif (CONFIG_DIMM_SLOTS_PER_CTLR == 2) 721 #ifdef CONFIG_FSL_DDR_FIRST_SLOT_QUAD_CAPABLE 722 if (pdimm[0].n_ranks == 4) 723 return FSL_DDR_CS0_CS1_CS2_CS3; 724 #endif 725 if (pdimm[0].n_ranks == 2) { 726 if (pdimm[1].n_ranks == 2) 727 return FSL_DDR_CS0_CS1_CS2_CS3; 728 else 729 return FSL_DDR_CS0_CS1; 730 } 731 #endif 732 return 0; 733 } 734 735 unsigned int populate_memctl_options(const common_timing_params_t *common_dimm, 736 memctl_options_t *popts, 737 dimm_params_t *pdimm, 738 unsigned int ctrl_num) 739 { 740 unsigned int i; 741 char buffer[HWCONFIG_BUFFER_SIZE]; 742 char *buf = NULL; 743 #if defined(CONFIG_SYS_FSL_DDR3) || \ 744 defined(CONFIG_SYS_FSL_DDR2) || \ 745 defined(CONFIG_SYS_FSL_DDR4) 746 const struct dynamic_odt *pdodt = odt_unknown; 747 #endif 748 ulong ddr_freq; 749 750 /* 751 * Extract hwconfig from environment since we have not properly setup 752 * the environment but need it for ddr config params 753 */ 754 if (getenv_f("hwconfig", buffer, sizeof(buffer)) > 0) 755 buf = buffer; 756 757 #if defined(CONFIG_SYS_FSL_DDR3) || \ 758 defined(CONFIG_SYS_FSL_DDR2) || \ 759 defined(CONFIG_SYS_FSL_DDR4) 760 /* Chip select options. */ 761 #if (CONFIG_DIMM_SLOTS_PER_CTLR == 1) 762 switch (pdimm[0].n_ranks) { 763 case 1: 764 pdodt = single_S; 765 break; 766 case 2: 767 pdodt = single_D; 768 break; 769 case 4: 770 pdodt = single_Q; 771 break; 772 } 773 #elif (CONFIG_DIMM_SLOTS_PER_CTLR == 2) 774 switch (pdimm[0].n_ranks) { 775 #ifdef CONFIG_FSL_DDR_FIRST_SLOT_QUAD_CAPABLE 776 case 4: 777 pdodt = single_Q; 778 if (pdimm[1].n_ranks) 779 printf("Error: Quad- and Dual-rank DIMMs cannot be used together\n"); 780 break; 781 #endif 782 case 2: 783 switch (pdimm[1].n_ranks) { 784 case 2: 785 pdodt = dual_DD; 786 break; 787 case 1: 788 pdodt = dual_DS; 789 break; 790 case 0: 791 pdodt = dual_D0; 792 break; 793 } 794 break; 795 case 1: 796 switch (pdimm[1].n_ranks) { 797 case 2: 798 pdodt = dual_SD; 799 break; 800 case 1: 801 pdodt = dual_SS; 802 break; 803 case 0: 804 pdodt = dual_S0; 805 break; 806 } 807 break; 808 case 0: 809 switch (pdimm[1].n_ranks) { 810 case 2: 811 pdodt = dual_0D; 812 break; 813 case 1: 814 pdodt = dual_0S; 815 break; 816 } 817 break; 818 } 819 #endif /* CONFIG_DIMM_SLOTS_PER_CTLR */ 820 #endif /* CONFIG_SYS_FSL_DDR2, 3, 4 */ 821 822 /* Pick chip-select local options. */ 823 for (i = 0; i < CONFIG_CHIP_SELECTS_PER_CTRL; i++) { 824 #if defined(CONFIG_SYS_FSL_DDR3) || \ 825 defined(CONFIG_SYS_FSL_DDR2) || \ 826 defined(CONFIG_SYS_FSL_DDR4) 827 popts->cs_local_opts[i].odt_rd_cfg = pdodt[i].odt_rd_cfg; 828 popts->cs_local_opts[i].odt_wr_cfg = pdodt[i].odt_wr_cfg; 829 popts->cs_local_opts[i].odt_rtt_norm = pdodt[i].odt_rtt_norm; 830 popts->cs_local_opts[i].odt_rtt_wr = pdodt[i].odt_rtt_wr; 831 #else 832 popts->cs_local_opts[i].odt_rd_cfg = FSL_DDR_ODT_NEVER; 833 popts->cs_local_opts[i].odt_wr_cfg = FSL_DDR_ODT_CS; 834 #endif 835 popts->cs_local_opts[i].auto_precharge = 0; 836 } 837 838 /* Pick interleaving mode. */ 839 840 /* 841 * 0 = no interleaving 842 * 1 = interleaving between 2 controllers 843 */ 844 popts->memctl_interleaving = 0; 845 846 /* 847 * 0 = cacheline 848 * 1 = page 849 * 2 = (logical) bank 850 * 3 = superbank (only if CS interleaving is enabled) 851 */ 852 popts->memctl_interleaving_mode = 0; 853 854 /* 855 * 0: cacheline: bit 30 of the 36-bit physical addr selects the memctl 856 * 1: page: bit to the left of the column bits selects the memctl 857 * 2: bank: bit to the left of the bank bits selects the memctl 858 * 3: superbank: bit to the left of the chip select selects the memctl 859 * 860 * NOTE: ba_intlv (rank interleaving) is independent of memory 861 * controller interleaving; it is only within a memory controller. 862 * Must use superbank interleaving if rank interleaving is used and 863 * memory controller interleaving is enabled. 864 */ 865 866 /* 867 * 0 = no 868 * 0x40 = CS0,CS1 869 * 0x20 = CS2,CS3 870 * 0x60 = CS0,CS1 + CS2,CS3 871 * 0x04 = CS0,CS1,CS2,CS3 872 */ 873 popts->ba_intlv_ctl = 0; 874 875 /* Memory Organization Parameters */ 876 popts->registered_dimm_en = common_dimm->all_dimms_registered; 877 878 /* Operational Mode Paramters */ 879 880 /* Pick ECC modes */ 881 popts->ecc_mode = 0; /* 0 = disabled, 1 = enabled */ 882 #ifdef CONFIG_DDR_ECC 883 if (hwconfig_sub_f("fsl_ddr", "ecc", buf)) { 884 if (hwconfig_subarg_cmp_f("fsl_ddr", "ecc", "on", buf)) 885 popts->ecc_mode = 1; 886 } else 887 popts->ecc_mode = 1; 888 #endif 889 popts->ecc_init_using_memctl = 1; /* 0 = use DMA, 1 = use memctl */ 890 891 /* 892 * Choose DQS config 893 * 0 for DDR1 894 * 1 for DDR2 895 */ 896 #if defined(CONFIG_SYS_FSL_DDR1) 897 popts->dqs_config = 0; 898 #elif defined(CONFIG_SYS_FSL_DDR2) || defined(CONFIG_SYS_FSL_DDR3) 899 popts->dqs_config = 1; 900 #endif 901 902 /* Choose self-refresh during sleep. */ 903 popts->self_refresh_in_sleep = 1; 904 905 /* Choose dynamic power management mode. */ 906 popts->dynamic_power = 0; 907 908 /* 909 * check first dimm for primary sdram width 910 * presuming all dimms are similar 911 * 0 = 64-bit, 1 = 32-bit, 2 = 16-bit 912 */ 913 #if defined(CONFIG_SYS_FSL_DDR1) || defined(CONFIG_SYS_FSL_DDR2) 914 if (pdimm[0].n_ranks != 0) { 915 if ((pdimm[0].data_width >= 64) && \ 916 (pdimm[0].data_width <= 72)) 917 popts->data_bus_width = 0; 918 else if ((pdimm[0].data_width >= 32) || \ 919 (pdimm[0].data_width <= 40)) 920 popts->data_bus_width = 1; 921 else { 922 panic("Error: data width %u is invalid!\n", 923 pdimm[0].data_width); 924 } 925 } 926 #else 927 if (pdimm[0].n_ranks != 0) { 928 if (pdimm[0].primary_sdram_width == 64) 929 popts->data_bus_width = 0; 930 else if (pdimm[0].primary_sdram_width == 32) 931 popts->data_bus_width = 1; 932 else if (pdimm[0].primary_sdram_width == 16) 933 popts->data_bus_width = 2; 934 else { 935 panic("Error: primary sdram width %u is invalid!\n", 936 pdimm[0].primary_sdram_width); 937 } 938 } 939 #endif 940 941 popts->x4_en = (pdimm[0].device_width == 4) ? 1 : 0; 942 943 /* Choose burst length. */ 944 #if defined(CONFIG_SYS_FSL_DDR3) || defined(CONFIG_SYS_FSL_DDR4) 945 #if defined(CONFIG_E500MC) 946 popts->otf_burst_chop_en = 0; /* on-the-fly burst chop disable */ 947 popts->burst_length = DDR_BL8; /* Fixed 8-beat burst len */ 948 #else 949 if ((popts->data_bus_width == 1) || (popts->data_bus_width == 2)) { 950 /* 32-bit or 16-bit bus */ 951 popts->otf_burst_chop_en = 0; 952 popts->burst_length = DDR_BL8; 953 } else { 954 popts->otf_burst_chop_en = 1; /* on-the-fly burst chop */ 955 popts->burst_length = DDR_OTF; /* on-the-fly BC4 and BL8 */ 956 } 957 #endif 958 #else 959 popts->burst_length = DDR_BL4; /* has to be 4 for DDR2 */ 960 #endif 961 962 /* Choose ddr controller address mirror mode */ 963 #if defined(CONFIG_SYS_FSL_DDR3) || defined(CONFIG_SYS_FSL_DDR4) 964 for (i = 0; i < CONFIG_DIMM_SLOTS_PER_CTLR; i++) { 965 if (pdimm[i].n_ranks) { 966 popts->mirrored_dimm = pdimm[i].mirrored_dimm; 967 break; 968 } 969 } 970 #endif 971 972 /* Global Timing Parameters. */ 973 debug("mclk_ps = %u ps\n", get_memory_clk_period_ps(ctrl_num)); 974 975 /* Pick a caslat override. */ 976 popts->cas_latency_override = 0; 977 popts->cas_latency_override_value = 3; 978 if (popts->cas_latency_override) { 979 debug("using caslat override value = %u\n", 980 popts->cas_latency_override_value); 981 } 982 983 /* Decide whether to use the computed derated latency */ 984 popts->use_derated_caslat = 0; 985 986 /* Choose an additive latency. */ 987 popts->additive_latency_override = 0; 988 popts->additive_latency_override_value = 3; 989 if (popts->additive_latency_override) { 990 debug("using additive latency override value = %u\n", 991 popts->additive_latency_override_value); 992 } 993 994 /* 995 * 2T_EN setting 996 * 997 * Factors to consider for 2T_EN: 998 * - number of DIMMs installed 999 * - number of components, number of active ranks 1000 * - how much time you want to spend playing around 1001 */ 1002 popts->twot_en = 0; 1003 popts->threet_en = 0; 1004 1005 /* for RDIMM and DDR4 UDIMM/discrete memory, address parity enable */ 1006 if (popts->registered_dimm_en) 1007 popts->ap_en = 1; /* 0 = disable, 1 = enable */ 1008 else 1009 popts->ap_en = 0; /* disabled for DDR4 UDIMM/discrete default */ 1010 1011 if (hwconfig_sub_f("fsl_ddr", "parity", buf)) { 1012 if (hwconfig_subarg_cmp_f("fsl_ddr", "parity", "on", buf)) { 1013 if (popts->registered_dimm_en || 1014 (CONFIG_FSL_SDRAM_TYPE == SDRAM_TYPE_DDR4)) 1015 popts->ap_en = 1; 1016 } 1017 } 1018 1019 /* 1020 * BSTTOPRE precharge interval 1021 * 1022 * Set this to 0 for global auto precharge 1023 * The value of 0x100 has been used for DDR1, DDR2, DDR3. 1024 * It is not wrong. Any value should be OK. The performance depends on 1025 * applications. There is no one good value for all. One way to set 1026 * is to use 1/4 of refint value. 1027 */ 1028 popts->bstopre = picos_to_mclk(ctrl_num, common_dimm->refresh_rate_ps) 1029 >> 2; 1030 1031 /* 1032 * Window for four activates -- tFAW 1033 * 1034 * FIXME: UM: applies only to DDR2/DDR3 with eight logical banks only 1035 * FIXME: varies depending upon number of column addresses or data 1036 * FIXME: width, was considering looking at pdimm->primary_sdram_width 1037 */ 1038 #if defined(CONFIG_SYS_FSL_DDR1) 1039 popts->tfaw_window_four_activates_ps = mclk_to_picos(ctrl_num, 1); 1040 1041 #elif defined(CONFIG_SYS_FSL_DDR2) 1042 /* 1043 * x4/x8; some datasheets have 35000 1044 * x16 wide columns only? Use 50000? 1045 */ 1046 popts->tfaw_window_four_activates_ps = 37500; 1047 1048 #else 1049 popts->tfaw_window_four_activates_ps = pdimm[0].tfaw_ps; 1050 #endif 1051 popts->zq_en = 0; 1052 popts->wrlvl_en = 0; 1053 #if defined(CONFIG_SYS_FSL_DDR3) || defined(CONFIG_SYS_FSL_DDR4) 1054 /* 1055 * due to ddr3 dimm is fly-by topology 1056 * we suggest to enable write leveling to 1057 * meet the tQDSS under different loading. 1058 */ 1059 popts->wrlvl_en = 1; 1060 popts->zq_en = 1; 1061 popts->wrlvl_override = 0; 1062 #endif 1063 1064 /* 1065 * Check interleaving configuration from environment. 1066 * Please refer to doc/README.fsl-ddr for the detail. 1067 * 1068 * If memory controller interleaving is enabled, then the data 1069 * bus widths must be programmed identically for all memory controllers. 1070 * 1071 * Attempt to set all controllers to the same chip select 1072 * interleaving mode. It will do a best effort to get the 1073 * requested ranks interleaved together such that the result 1074 * should be a subset of the requested configuration. 1075 * 1076 * if CONFIG_SYS_FSL_DDR_INTLV_256B is defined, mandatory interleaving 1077 * with 256 Byte is enabled. 1078 */ 1079 #if (CONFIG_NUM_DDR_CONTROLLERS > 1) 1080 if (!hwconfig_sub_f("fsl_ddr", "ctlr_intlv", buf)) 1081 #ifdef CONFIG_SYS_FSL_DDR_INTLV_256B 1082 ; 1083 #else 1084 goto done; 1085 #endif 1086 if (pdimm[0].n_ranks == 0) { 1087 printf("There is no rank on CS0 for controller %d.\n", ctrl_num); 1088 popts->memctl_interleaving = 0; 1089 goto done; 1090 } 1091 popts->memctl_interleaving = 1; 1092 #ifdef CONFIG_SYS_FSL_DDR_INTLV_256B 1093 popts->memctl_interleaving_mode = FSL_DDR_256B_INTERLEAVING; 1094 popts->memctl_interleaving = 1; 1095 debug("256 Byte interleaving\n"); 1096 #else 1097 /* 1098 * test null first. if CONFIG_HWCONFIG is not defined 1099 * hwconfig_arg_cmp returns non-zero 1100 */ 1101 if (hwconfig_subarg_cmp_f("fsl_ddr", "ctlr_intlv", 1102 "null", buf)) { 1103 popts->memctl_interleaving = 0; 1104 debug("memory controller interleaving disabled.\n"); 1105 } else if (hwconfig_subarg_cmp_f("fsl_ddr", 1106 "ctlr_intlv", 1107 "cacheline", buf)) { 1108 popts->memctl_interleaving_mode = 1109 ((CONFIG_NUM_DDR_CONTROLLERS == 3) && ctrl_num == 2) ? 1110 0 : FSL_DDR_CACHE_LINE_INTERLEAVING; 1111 popts->memctl_interleaving = 1112 ((CONFIG_NUM_DDR_CONTROLLERS == 3) && ctrl_num == 2) ? 1113 0 : 1; 1114 } else if (hwconfig_subarg_cmp_f("fsl_ddr", 1115 "ctlr_intlv", 1116 "page", buf)) { 1117 popts->memctl_interleaving_mode = 1118 ((CONFIG_NUM_DDR_CONTROLLERS == 3) && ctrl_num == 2) ? 1119 0 : FSL_DDR_PAGE_INTERLEAVING; 1120 popts->memctl_interleaving = 1121 ((CONFIG_NUM_DDR_CONTROLLERS == 3) && ctrl_num == 2) ? 1122 0 : 1; 1123 } else if (hwconfig_subarg_cmp_f("fsl_ddr", 1124 "ctlr_intlv", 1125 "bank", buf)) { 1126 popts->memctl_interleaving_mode = 1127 ((CONFIG_NUM_DDR_CONTROLLERS == 3) && ctrl_num == 2) ? 1128 0 : FSL_DDR_BANK_INTERLEAVING; 1129 popts->memctl_interleaving = 1130 ((CONFIG_NUM_DDR_CONTROLLERS == 3) && ctrl_num == 2) ? 1131 0 : 1; 1132 } else if (hwconfig_subarg_cmp_f("fsl_ddr", 1133 "ctlr_intlv", 1134 "superbank", buf)) { 1135 popts->memctl_interleaving_mode = 1136 ((CONFIG_NUM_DDR_CONTROLLERS == 3) && ctrl_num == 2) ? 1137 0 : FSL_DDR_SUPERBANK_INTERLEAVING; 1138 popts->memctl_interleaving = 1139 ((CONFIG_NUM_DDR_CONTROLLERS == 3) && ctrl_num == 2) ? 1140 0 : 1; 1141 #if (CONFIG_NUM_DDR_CONTROLLERS == 3) 1142 } else if (hwconfig_subarg_cmp_f("fsl_ddr", 1143 "ctlr_intlv", 1144 "3way_1KB", buf)) { 1145 popts->memctl_interleaving_mode = 1146 FSL_DDR_3WAY_1KB_INTERLEAVING; 1147 } else if (hwconfig_subarg_cmp_f("fsl_ddr", 1148 "ctlr_intlv", 1149 "3way_4KB", buf)) { 1150 popts->memctl_interleaving_mode = 1151 FSL_DDR_3WAY_4KB_INTERLEAVING; 1152 } else if (hwconfig_subarg_cmp_f("fsl_ddr", 1153 "ctlr_intlv", 1154 "3way_8KB", buf)) { 1155 popts->memctl_interleaving_mode = 1156 FSL_DDR_3WAY_8KB_INTERLEAVING; 1157 #elif (CONFIG_NUM_DDR_CONTROLLERS == 4) 1158 } else if (hwconfig_subarg_cmp_f("fsl_ddr", 1159 "ctlr_intlv", 1160 "4way_1KB", buf)) { 1161 popts->memctl_interleaving_mode = 1162 FSL_DDR_4WAY_1KB_INTERLEAVING; 1163 } else if (hwconfig_subarg_cmp_f("fsl_ddr", 1164 "ctlr_intlv", 1165 "4way_4KB", buf)) { 1166 popts->memctl_interleaving_mode = 1167 FSL_DDR_4WAY_4KB_INTERLEAVING; 1168 } else if (hwconfig_subarg_cmp_f("fsl_ddr", 1169 "ctlr_intlv", 1170 "4way_8KB", buf)) { 1171 popts->memctl_interleaving_mode = 1172 FSL_DDR_4WAY_8KB_INTERLEAVING; 1173 #endif 1174 } else { 1175 popts->memctl_interleaving = 0; 1176 printf("hwconfig has unrecognized parameter for ctlr_intlv.\n"); 1177 } 1178 #endif /* CONFIG_SYS_FSL_DDR_INTLV_256B */ 1179 done: 1180 #endif /* CONFIG_NUM_DDR_CONTROLLERS > 1 */ 1181 if ((hwconfig_sub_f("fsl_ddr", "bank_intlv", buf)) && 1182 (CONFIG_CHIP_SELECTS_PER_CTRL > 1)) { 1183 /* test null first. if CONFIG_HWCONFIG is not defined, 1184 * hwconfig_subarg_cmp_f returns non-zero */ 1185 if (hwconfig_subarg_cmp_f("fsl_ddr", "bank_intlv", 1186 "null", buf)) 1187 debug("bank interleaving disabled.\n"); 1188 else if (hwconfig_subarg_cmp_f("fsl_ddr", "bank_intlv", 1189 "cs0_cs1", buf)) 1190 popts->ba_intlv_ctl = FSL_DDR_CS0_CS1; 1191 else if (hwconfig_subarg_cmp_f("fsl_ddr", "bank_intlv", 1192 "cs2_cs3", buf)) 1193 popts->ba_intlv_ctl = FSL_DDR_CS2_CS3; 1194 else if (hwconfig_subarg_cmp_f("fsl_ddr", "bank_intlv", 1195 "cs0_cs1_and_cs2_cs3", buf)) 1196 popts->ba_intlv_ctl = FSL_DDR_CS0_CS1_AND_CS2_CS3; 1197 else if (hwconfig_subarg_cmp_f("fsl_ddr", "bank_intlv", 1198 "cs0_cs1_cs2_cs3", buf)) 1199 popts->ba_intlv_ctl = FSL_DDR_CS0_CS1_CS2_CS3; 1200 else if (hwconfig_subarg_cmp_f("fsl_ddr", "bank_intlv", 1201 "auto", buf)) 1202 popts->ba_intlv_ctl = auto_bank_intlv(pdimm); 1203 else 1204 printf("hwconfig has unrecognized parameter for bank_intlv.\n"); 1205 switch (popts->ba_intlv_ctl & FSL_DDR_CS0_CS1_CS2_CS3) { 1206 case FSL_DDR_CS0_CS1_CS2_CS3: 1207 #if (CONFIG_DIMM_SLOTS_PER_CTLR == 1) 1208 if (pdimm[0].n_ranks < 4) { 1209 popts->ba_intlv_ctl = 0; 1210 printf("Not enough bank(chip-select) for " 1211 "CS0+CS1+CS2+CS3 on controller %d, " 1212 "interleaving disabled!\n", ctrl_num); 1213 } 1214 #elif (CONFIG_DIMM_SLOTS_PER_CTLR == 2) 1215 #ifdef CONFIG_FSL_DDR_FIRST_SLOT_QUAD_CAPABLE 1216 if (pdimm[0].n_ranks == 4) 1217 break; 1218 #endif 1219 if ((pdimm[0].n_ranks < 2) && (pdimm[1].n_ranks < 2)) { 1220 popts->ba_intlv_ctl = 0; 1221 printf("Not enough bank(chip-select) for " 1222 "CS0+CS1+CS2+CS3 on controller %d, " 1223 "interleaving disabled!\n", ctrl_num); 1224 } 1225 if (pdimm[0].capacity != pdimm[1].capacity) { 1226 popts->ba_intlv_ctl = 0; 1227 printf("Not identical DIMM size for " 1228 "CS0+CS1+CS2+CS3 on controller %d, " 1229 "interleaving disabled!\n", ctrl_num); 1230 } 1231 #endif 1232 break; 1233 case FSL_DDR_CS0_CS1: 1234 if (pdimm[0].n_ranks < 2) { 1235 popts->ba_intlv_ctl = 0; 1236 printf("Not enough bank(chip-select) for " 1237 "CS0+CS1 on controller %d, " 1238 "interleaving disabled!\n", ctrl_num); 1239 } 1240 break; 1241 case FSL_DDR_CS2_CS3: 1242 #if (CONFIG_DIMM_SLOTS_PER_CTLR == 1) 1243 if (pdimm[0].n_ranks < 4) { 1244 popts->ba_intlv_ctl = 0; 1245 printf("Not enough bank(chip-select) for CS2+CS3 " 1246 "on controller %d, interleaving disabled!\n", ctrl_num); 1247 } 1248 #elif (CONFIG_DIMM_SLOTS_PER_CTLR == 2) 1249 if (pdimm[1].n_ranks < 2) { 1250 popts->ba_intlv_ctl = 0; 1251 printf("Not enough bank(chip-select) for CS2+CS3 " 1252 "on controller %d, interleaving disabled!\n", ctrl_num); 1253 } 1254 #endif 1255 break; 1256 case FSL_DDR_CS0_CS1_AND_CS2_CS3: 1257 #if (CONFIG_DIMM_SLOTS_PER_CTLR == 1) 1258 if (pdimm[0].n_ranks < 4) { 1259 popts->ba_intlv_ctl = 0; 1260 printf("Not enough bank(CS) for CS0+CS1 and " 1261 "CS2+CS3 on controller %d, " 1262 "interleaving disabled!\n", ctrl_num); 1263 } 1264 #elif (CONFIG_DIMM_SLOTS_PER_CTLR == 2) 1265 if ((pdimm[0].n_ranks < 2) || (pdimm[1].n_ranks < 2)) { 1266 popts->ba_intlv_ctl = 0; 1267 printf("Not enough bank(CS) for CS0+CS1 and " 1268 "CS2+CS3 on controller %d, " 1269 "interleaving disabled!\n", ctrl_num); 1270 } 1271 #endif 1272 break; 1273 default: 1274 popts->ba_intlv_ctl = 0; 1275 break; 1276 } 1277 } 1278 1279 if (hwconfig_sub_f("fsl_ddr", "addr_hash", buf)) { 1280 if (hwconfig_subarg_cmp_f("fsl_ddr", "addr_hash", "null", buf)) 1281 popts->addr_hash = 0; 1282 else if (hwconfig_subarg_cmp_f("fsl_ddr", "addr_hash", 1283 "true", buf)) 1284 popts->addr_hash = 1; 1285 } 1286 1287 if (pdimm[0].n_ranks == 4) 1288 popts->quad_rank_present = 1; 1289 1290 ddr_freq = get_ddr_freq(ctrl_num) / 1000000; 1291 if (popts->registered_dimm_en) { 1292 popts->rcw_override = 1; 1293 popts->rcw_1 = 0x000a5a00; 1294 if (ddr_freq <= 800) 1295 popts->rcw_2 = 0x00000000; 1296 else if (ddr_freq <= 1066) 1297 popts->rcw_2 = 0x00100000; 1298 else if (ddr_freq <= 1333) 1299 popts->rcw_2 = 0x00200000; 1300 else 1301 popts->rcw_2 = 0x00300000; 1302 } 1303 1304 fsl_ddr_board_options(popts, pdimm, ctrl_num); 1305 1306 return 0; 1307 } 1308 1309 void check_interleaving_options(fsl_ddr_info_t *pinfo) 1310 { 1311 int i, j, k, check_n_ranks, intlv_invalid = 0; 1312 unsigned int check_intlv, check_n_row_addr, check_n_col_addr; 1313 unsigned long long check_rank_density; 1314 struct dimm_params_s *dimm; 1315 int first_ctrl = pinfo->first_ctrl; 1316 int last_ctrl = first_ctrl + pinfo->num_ctrls - 1; 1317 1318 /* 1319 * Check if all controllers are configured for memory 1320 * controller interleaving. Identical dimms are recommended. At least 1321 * the size, row and col address should be checked. 1322 */ 1323 j = 0; 1324 check_n_ranks = pinfo->dimm_params[first_ctrl][0].n_ranks; 1325 check_rank_density = pinfo->dimm_params[first_ctrl][0].rank_density; 1326 check_n_row_addr = pinfo->dimm_params[first_ctrl][0].n_row_addr; 1327 check_n_col_addr = pinfo->dimm_params[first_ctrl][0].n_col_addr; 1328 check_intlv = pinfo->memctl_opts[first_ctrl].memctl_interleaving_mode; 1329 for (i = first_ctrl; i <= last_ctrl; i++) { 1330 dimm = &pinfo->dimm_params[i][0]; 1331 if (!pinfo->memctl_opts[i].memctl_interleaving) { 1332 continue; 1333 } else if (((check_rank_density != dimm->rank_density) || 1334 (check_n_ranks != dimm->n_ranks) || 1335 (check_n_row_addr != dimm->n_row_addr) || 1336 (check_n_col_addr != dimm->n_col_addr) || 1337 (check_intlv != 1338 pinfo->memctl_opts[i].memctl_interleaving_mode))){ 1339 intlv_invalid = 1; 1340 break; 1341 } else { 1342 j++; 1343 } 1344 1345 } 1346 if (intlv_invalid) { 1347 for (i = first_ctrl; i <= last_ctrl; i++) 1348 pinfo->memctl_opts[i].memctl_interleaving = 0; 1349 printf("Not all DIMMs are identical. " 1350 "Memory controller interleaving disabled.\n"); 1351 } else { 1352 switch (check_intlv) { 1353 case FSL_DDR_256B_INTERLEAVING: 1354 case FSL_DDR_CACHE_LINE_INTERLEAVING: 1355 case FSL_DDR_PAGE_INTERLEAVING: 1356 case FSL_DDR_BANK_INTERLEAVING: 1357 case FSL_DDR_SUPERBANK_INTERLEAVING: 1358 #if (3 == CONFIG_NUM_DDR_CONTROLLERS) 1359 k = 2; 1360 #else 1361 k = CONFIG_NUM_DDR_CONTROLLERS; 1362 #endif 1363 break; 1364 case FSL_DDR_3WAY_1KB_INTERLEAVING: 1365 case FSL_DDR_3WAY_4KB_INTERLEAVING: 1366 case FSL_DDR_3WAY_8KB_INTERLEAVING: 1367 case FSL_DDR_4WAY_1KB_INTERLEAVING: 1368 case FSL_DDR_4WAY_4KB_INTERLEAVING: 1369 case FSL_DDR_4WAY_8KB_INTERLEAVING: 1370 default: 1371 k = CONFIG_NUM_DDR_CONTROLLERS; 1372 break; 1373 } 1374 debug("%d of %d controllers are interleaving.\n", j, k); 1375 if (j && (j != k)) { 1376 for (i = first_ctrl; i <= last_ctrl; i++) 1377 pinfo->memctl_opts[i].memctl_interleaving = 0; 1378 if ((last_ctrl - first_ctrl) > 1) 1379 puts("Not all controllers have compatible interleaving mode. All disabled.\n"); 1380 } 1381 } 1382 debug("Checking interleaving options completed\n"); 1383 } 1384 1385 int fsl_use_spd(void) 1386 { 1387 int use_spd = 0; 1388 1389 #ifdef CONFIG_DDR_SPD 1390 char buffer[HWCONFIG_BUFFER_SIZE]; 1391 char *buf = NULL; 1392 1393 /* 1394 * Extract hwconfig from environment since we have not properly setup 1395 * the environment but need it for ddr config params 1396 */ 1397 if (getenv_f("hwconfig", buffer, sizeof(buffer)) > 0) 1398 buf = buffer; 1399 1400 /* if hwconfig is not enabled, or "sdram" is not defined, use spd */ 1401 if (hwconfig_sub_f("fsl_ddr", "sdram", buf)) { 1402 if (hwconfig_subarg_cmp_f("fsl_ddr", "sdram", "spd", buf)) 1403 use_spd = 1; 1404 else if (hwconfig_subarg_cmp_f("fsl_ddr", "sdram", 1405 "fixed", buf)) 1406 use_spd = 0; 1407 else 1408 use_spd = 1; 1409 } else 1410 use_spd = 1; 1411 #endif 1412 1413 return use_spd; 1414 } 1415