1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Copyright 2014 Freescale Semiconductor, Inc. 4 */ 5 6 #include <common.h> 7 #include <command.h> 8 #include <i2c.h> 9 #include <asm/io.h> 10 #ifdef CONFIG_FSL_LSCH2 11 #include <asm/arch/immap_lsch2.h> 12 #elif defined(CONFIG_FSL_LSCH3) 13 #include <asm/arch/immap_lsch3.h> 14 #else 15 #include <asm/immap_85xx.h> 16 #endif 17 #include "vid.h" 18 19 int __weak i2c_multiplexer_select_vid_channel(u8 channel) 20 { 21 return 0; 22 } 23 24 /* 25 * Compensate for a board specific voltage drop between regulator and SoC 26 * return a value in mV 27 */ 28 int __weak board_vdd_drop_compensation(void) 29 { 30 return 0; 31 } 32 33 /* 34 * Board specific settings for specific voltage value 35 */ 36 int __weak board_adjust_vdd(int vdd) 37 { 38 return 0; 39 } 40 41 #if defined(CONFIG_VOL_MONITOR_IR36021_SET) || \ 42 defined(CONFIG_VOL_MONITOR_IR36021_READ) 43 /* 44 * Get the i2c address configuration for the IR regulator chip 45 * 46 * There are some variance in the RDB HW regarding the I2C address configuration 47 * for the IR regulator chip, which is likely a problem of external resistor 48 * accuracy. So we just check each address in a hopefully non-intrusive mode 49 * and use the first one that seems to work 50 * 51 * The IR chip can show up under the following addresses: 52 * 0x08 (Verified on T1040RDB-PA,T4240RDB-PB,X-T4240RDB-16GPA) 53 * 0x09 (Verified on T1040RDB-PA) 54 * 0x38 (Verified on T2080QDS, T2081QDS, T4240RDB) 55 */ 56 static int find_ir_chip_on_i2c(void) 57 { 58 int i2caddress; 59 int ret; 60 u8 byte; 61 int i; 62 const int ir_i2c_addr[] = {0x38, 0x08, 0x09}; 63 64 /* Check all the address */ 65 for (i = 0; i < (sizeof(ir_i2c_addr)/sizeof(ir_i2c_addr[0])); i++) { 66 i2caddress = ir_i2c_addr[i]; 67 ret = i2c_read(i2caddress, 68 IR36021_MFR_ID_OFFSET, 1, (void *)&byte, 69 sizeof(byte)); 70 if ((ret >= 0) && (byte == IR36021_MFR_ID)) 71 return i2caddress; 72 } 73 return -1; 74 } 75 #endif 76 77 /* Maximum loop count waiting for new voltage to take effect */ 78 #define MAX_LOOP_WAIT_NEW_VOL 100 79 /* Maximum loop count waiting for the voltage to be stable */ 80 #define MAX_LOOP_WAIT_VOL_STABLE 100 81 /* 82 * read_voltage from sensor on I2C bus 83 * We use average of 4 readings, waiting for WAIT_FOR_ADC before 84 * another reading 85 */ 86 #define NUM_READINGS 4 /* prefer to be power of 2 for efficiency */ 87 88 /* If an INA220 chip is available, we can use it to read back the voltage 89 * as it may have a higher accuracy than the IR chip for the same purpose 90 */ 91 #ifdef CONFIG_VOL_MONITOR_INA220 92 #define WAIT_FOR_ADC 532 /* wait for 532 microseconds for ADC */ 93 #define ADC_MIN_ACCURACY 4 94 #else 95 #define WAIT_FOR_ADC 138 /* wait for 138 microseconds for ADC */ 96 #define ADC_MIN_ACCURACY 4 97 #endif 98 99 #ifdef CONFIG_VOL_MONITOR_INA220 100 static int read_voltage_from_INA220(int i2caddress) 101 { 102 int i, ret, voltage_read = 0; 103 u16 vol_mon; 104 u8 buf[2]; 105 106 for (i = 0; i < NUM_READINGS; i++) { 107 ret = i2c_read(I2C_VOL_MONITOR_ADDR, 108 I2C_VOL_MONITOR_BUS_V_OFFSET, 1, 109 (void *)&buf, 2); 110 if (ret) { 111 printf("VID: failed to read core voltage\n"); 112 return ret; 113 } 114 vol_mon = (buf[0] << 8) | buf[1]; 115 if (vol_mon & I2C_VOL_MONITOR_BUS_V_OVF) { 116 printf("VID: Core voltage sensor error\n"); 117 return -1; 118 } 119 debug("VID: bus voltage reads 0x%04x\n", vol_mon); 120 /* LSB = 4mv */ 121 voltage_read += (vol_mon >> I2C_VOL_MONITOR_BUS_V_SHIFT) * 4; 122 udelay(WAIT_FOR_ADC); 123 } 124 /* calculate the average */ 125 voltage_read /= NUM_READINGS; 126 127 return voltage_read; 128 } 129 #endif 130 131 /* read voltage from IR */ 132 #ifdef CONFIG_VOL_MONITOR_IR36021_READ 133 static int read_voltage_from_IR(int i2caddress) 134 { 135 int i, ret, voltage_read = 0; 136 u16 vol_mon; 137 u8 buf; 138 139 for (i = 0; i < NUM_READINGS; i++) { 140 ret = i2c_read(i2caddress, 141 IR36021_LOOP1_VOUT_OFFSET, 142 1, (void *)&buf, 1); 143 if (ret) { 144 printf("VID: failed to read vcpu\n"); 145 return ret; 146 } 147 vol_mon = buf; 148 if (!vol_mon) { 149 printf("VID: Core voltage sensor error\n"); 150 return -1; 151 } 152 debug("VID: bus voltage reads 0x%02x\n", vol_mon); 153 /* Resolution is 1/128V. We scale up here to get 1/128mV 154 * and divide at the end 155 */ 156 voltage_read += vol_mon * 1000; 157 udelay(WAIT_FOR_ADC); 158 } 159 /* Scale down to the real mV as IR resolution is 1/128V, rounding up */ 160 voltage_read = DIV_ROUND_UP(voltage_read, 128); 161 162 /* calculate the average */ 163 voltage_read /= NUM_READINGS; 164 165 /* Compensate for a board specific voltage drop between regulator and 166 * SoC before converting into an IR VID value 167 */ 168 voltage_read -= board_vdd_drop_compensation(); 169 170 return voltage_read; 171 } 172 #endif 173 174 #ifdef CONFIG_VOL_MONITOR_LTC3882_READ 175 /* read the current value of the LTC Regulator Voltage */ 176 static int read_voltage_from_LTC(int i2caddress) 177 { 178 int ret, vcode = 0; 179 u8 chan = PWM_CHANNEL0; 180 181 /* select the PAGE 0 using PMBus commands PAGE for VDD*/ 182 ret = i2c_write(I2C_VOL_MONITOR_ADDR, 183 PMBUS_CMD_PAGE, 1, &chan, 1); 184 if (ret) { 185 printf("VID: failed to select VDD Page 0\n"); 186 return ret; 187 } 188 189 /*read the output voltage using PMBus command READ_VOUT*/ 190 ret = i2c_read(I2C_VOL_MONITOR_ADDR, 191 PMBUS_CMD_READ_VOUT, 1, (void *)&vcode, 2); 192 if (ret) { 193 printf("VID: failed to read the volatge\n"); 194 return ret; 195 } 196 197 /* Scale down to the real mV as LTC resolution is 1/4096V,rounding up */ 198 vcode = DIV_ROUND_UP(vcode * 1000, 4096); 199 200 return vcode; 201 } 202 #endif 203 204 static int read_voltage(int i2caddress) 205 { 206 int voltage_read; 207 #ifdef CONFIG_VOL_MONITOR_INA220 208 voltage_read = read_voltage_from_INA220(i2caddress); 209 #elif defined CONFIG_VOL_MONITOR_IR36021_READ 210 voltage_read = read_voltage_from_IR(i2caddress); 211 #elif defined CONFIG_VOL_MONITOR_LTC3882_READ 212 voltage_read = read_voltage_from_LTC(i2caddress); 213 #else 214 return -1; 215 #endif 216 return voltage_read; 217 } 218 219 #ifdef CONFIG_VOL_MONITOR_IR36021_SET 220 /* 221 * We need to calculate how long before the voltage stops to drop 222 * or increase. It returns with the loop count. Each loop takes 223 * several readings (WAIT_FOR_ADC) 224 */ 225 static int wait_for_new_voltage(int vdd, int i2caddress) 226 { 227 int timeout, vdd_current; 228 229 vdd_current = read_voltage(i2caddress); 230 /* wait until voltage starts to reach the target. Voltage slew 231 * rates by typical regulators will always lead to stable readings 232 * within each fairly long ADC interval in comparison to the 233 * intended voltage delta change until the target voltage is 234 * reached. The fairly small voltage delta change to any target 235 * VID voltage also means that this function will always complete 236 * within few iterations. If the timeout was ever reached, it would 237 * point to a serious failure in the regulator system. 238 */ 239 for (timeout = 0; 240 abs(vdd - vdd_current) > (IR_VDD_STEP_UP + IR_VDD_STEP_DOWN) && 241 timeout < MAX_LOOP_WAIT_NEW_VOL; timeout++) { 242 vdd_current = read_voltage(i2caddress); 243 } 244 if (timeout >= MAX_LOOP_WAIT_NEW_VOL) { 245 printf("VID: Voltage adjustment timeout\n"); 246 return -1; 247 } 248 return timeout; 249 } 250 251 /* 252 * this function keeps reading the voltage until it is stable or until the 253 * timeout expires 254 */ 255 static int wait_for_voltage_stable(int i2caddress) 256 { 257 int timeout, vdd_current, vdd; 258 259 vdd = read_voltage(i2caddress); 260 udelay(NUM_READINGS * WAIT_FOR_ADC); 261 262 /* wait until voltage is stable */ 263 vdd_current = read_voltage(i2caddress); 264 /* The maximum timeout is 265 * MAX_LOOP_WAIT_VOL_STABLE * NUM_READINGS * WAIT_FOR_ADC 266 */ 267 for (timeout = MAX_LOOP_WAIT_VOL_STABLE; 268 abs(vdd - vdd_current) > ADC_MIN_ACCURACY && 269 timeout > 0; timeout--) { 270 vdd = vdd_current; 271 udelay(NUM_READINGS * WAIT_FOR_ADC); 272 vdd_current = read_voltage(i2caddress); 273 } 274 if (timeout == 0) 275 return -1; 276 return vdd_current; 277 } 278 279 /* Set the voltage to the IR chip */ 280 static int set_voltage_to_IR(int i2caddress, int vdd) 281 { 282 int wait, vdd_last; 283 int ret; 284 u8 vid; 285 286 /* Compensate for a board specific voltage drop between regulator and 287 * SoC before converting into an IR VID value 288 */ 289 vdd += board_vdd_drop_compensation(); 290 #ifdef CONFIG_FSL_LSCH2 291 vid = DIV_ROUND_UP(vdd - 265, 5); 292 #else 293 vid = DIV_ROUND_UP(vdd - 245, 5); 294 #endif 295 296 ret = i2c_write(i2caddress, IR36021_LOOP1_MANUAL_ID_OFFSET, 297 1, (void *)&vid, sizeof(vid)); 298 if (ret) { 299 printf("VID: failed to write VID\n"); 300 return -1; 301 } 302 wait = wait_for_new_voltage(vdd, i2caddress); 303 if (wait < 0) 304 return -1; 305 debug("VID: Waited %d us\n", wait * NUM_READINGS * WAIT_FOR_ADC); 306 307 vdd_last = wait_for_voltage_stable(i2caddress); 308 if (vdd_last < 0) 309 return -1; 310 debug("VID: Current voltage is %d mV\n", vdd_last); 311 return vdd_last; 312 } 313 314 #endif 315 316 #ifdef CONFIG_VOL_MONITOR_LTC3882_SET 317 /* this function sets the VDD and returns the value set */ 318 static int set_voltage_to_LTC(int i2caddress, int vdd) 319 { 320 int ret, vdd_last, vdd_target = vdd; 321 int count = 100, temp = 0; 322 323 /* Scale up to the LTC resolution is 1/4096V */ 324 vdd = (vdd * 4096) / 1000; 325 326 /* 5-byte buffer which needs to be sent following the 327 * PMBus command PAGE_PLUS_WRITE. 328 */ 329 u8 buff[5] = {0x04, PWM_CHANNEL0, PMBUS_CMD_VOUT_COMMAND, 330 vdd & 0xFF, (vdd & 0xFF00) >> 8}; 331 332 /* Write the desired voltage code to the regulator */ 333 ret = i2c_write(I2C_VOL_MONITOR_ADDR, 334 PMBUS_CMD_PAGE_PLUS_WRITE, 1, (void *)&buff, 5); 335 if (ret) { 336 printf("VID: I2C failed to write to the volatge regulator\n"); 337 return -1; 338 } 339 340 /* Wait for the volatge to get to the desired value */ 341 do { 342 vdd_last = read_voltage_from_LTC(i2caddress); 343 if (vdd_last < 0) { 344 printf("VID: Couldn't read sensor abort VID adjust\n"); 345 return -1; 346 } 347 count--; 348 temp = vdd_last - vdd_target; 349 } while ((abs(temp) > 2) && (count > 0)); 350 351 return vdd_last; 352 } 353 #endif 354 355 static int set_voltage(int i2caddress, int vdd) 356 { 357 int vdd_last = -1; 358 359 #ifdef CONFIG_VOL_MONITOR_IR36021_SET 360 vdd_last = set_voltage_to_IR(i2caddress, vdd); 361 #elif defined CONFIG_VOL_MONITOR_LTC3882_SET 362 vdd_last = set_voltage_to_LTC(i2caddress, vdd); 363 #else 364 #error Specific voltage monitor must be defined 365 #endif 366 return vdd_last; 367 } 368 369 #ifdef CONFIG_FSL_LSCH3 370 int adjust_vdd(ulong vdd_override) 371 { 372 int re_enable = disable_interrupts(); 373 struct ccsr_gur *gur = (void *)(CONFIG_SYS_FSL_GUTS_ADDR); 374 u32 fusesr; 375 #if defined(CONFIG_VOL_MONITOR_IR36021_SET) || \ 376 defined(CONFIG_VOL_MONITOR_IR36021_READ) 377 u8 vid, buf; 378 #else 379 u8 vid; 380 #endif 381 int vdd_target, vdd_current, vdd_last; 382 int ret, i2caddress; 383 unsigned long vdd_string_override; 384 char *vdd_string; 385 #ifdef CONFIG_ARCH_LX2160A 386 static const u16 vdd[32] = { 387 8250, 388 7875, 389 7750, 390 0, /* reserved */ 391 0, /* reserved */ 392 0, /* reserved */ 393 0, /* reserved */ 394 0, /* reserved */ 395 0, /* reserved */ 396 0, /* reserved */ 397 0, /* reserved */ 398 0, /* reserved */ 399 0, /* reserved */ 400 0, /* reserved */ 401 0, /* reserved */ 402 0, /* reserved */ 403 8000, 404 8125, 405 8250, 406 0, /* reserved */ 407 8500, 408 0, /* reserved */ 409 0, /* reserved */ 410 0, /* reserved */ 411 0, /* reserved */ 412 0, /* reserved */ 413 0, /* reserved */ 414 0, /* reserved */ 415 0, /* reserved */ 416 0, /* reserved */ 417 0, /* reserved */ 418 0, /* reserved */ 419 }; 420 #else 421 #ifdef CONFIG_ARCH_LS1088A 422 static const uint16_t vdd[32] = { 423 10250, 424 9875, 425 9750, 426 0, /* reserved */ 427 0, /* reserved */ 428 0, /* reserved */ 429 0, /* reserved */ 430 0, /* reserved */ 431 9000, 432 0, /* reserved */ 433 0, /* reserved */ 434 0, /* reserved */ 435 0, /* reserved */ 436 0, /* reserved */ 437 0, /* reserved */ 438 0, /* reserved */ 439 10000, /* 1.0000V */ 440 10125, 441 10250, 442 0, /* reserved */ 443 0, /* reserved */ 444 0, /* reserved */ 445 0, /* reserved */ 446 0, /* reserved */ 447 0, /* reserved */ 448 0, /* reserved */ 449 0, /* reserved */ 450 0, /* reserved */ 451 0, /* reserved */ 452 0, /* reserved */ 453 0, /* reserved */ 454 0, /* reserved */ 455 }; 456 457 #else 458 static const uint16_t vdd[32] = { 459 10500, 460 0, /* reserved */ 461 9750, 462 0, /* reserved */ 463 9500, 464 0, /* reserved */ 465 0, /* reserved */ 466 0, /* reserved */ 467 0, /* reserved */ 468 0, /* reserved */ 469 0, /* reserved */ 470 9000, /* reserved */ 471 0, /* reserved */ 472 0, /* reserved */ 473 0, /* reserved */ 474 0, /* reserved */ 475 10000, /* 1.0000V */ 476 0, /* reserved */ 477 10250, 478 0, /* reserved */ 479 10500, 480 0, /* reserved */ 481 0, /* reserved */ 482 0, /* reserved */ 483 0, /* reserved */ 484 0, /* reserved */ 485 0, /* reserved */ 486 0, /* reserved */ 487 0, /* reserved */ 488 0, /* reserved */ 489 0, /* reserved */ 490 0, /* reserved */ 491 }; 492 #endif 493 #endif 494 struct vdd_drive { 495 u8 vid; 496 unsigned voltage; 497 }; 498 499 ret = i2c_multiplexer_select_vid_channel(I2C_MUX_CH_VOL_MONITOR); 500 if (ret) { 501 debug("VID: I2C failed to switch channel\n"); 502 ret = -1; 503 goto exit; 504 } 505 #if defined(CONFIG_VOL_MONITOR_IR36021_SET) || \ 506 defined(CONFIG_VOL_MONITOR_IR36021_READ) 507 ret = find_ir_chip_on_i2c(); 508 if (ret < 0) { 509 printf("VID: Could not find voltage regulator on I2C.\n"); 510 ret = -1; 511 goto exit; 512 } else { 513 i2caddress = ret; 514 debug("VID: IR Chip found on I2C address 0x%02x\n", i2caddress); 515 } 516 517 /* check IR chip work on Intel mode*/ 518 ret = i2c_read(i2caddress, 519 IR36021_INTEL_MODE_OOFSET, 520 1, (void *)&buf, 1); 521 if (ret) { 522 printf("VID: failed to read IR chip mode.\n"); 523 ret = -1; 524 goto exit; 525 } 526 if ((buf & IR36021_MODE_MASK) != IR36021_INTEL_MODE) { 527 printf("VID: IR Chip is not used in Intel mode.\n"); 528 ret = -1; 529 goto exit; 530 } 531 #endif 532 533 /* get the voltage ID from fuse status register */ 534 fusesr = in_le32(&gur->dcfg_fusesr); 535 vid = (fusesr >> FSL_CHASSIS3_DCFG_FUSESR_ALTVID_SHIFT) & 536 FSL_CHASSIS3_DCFG_FUSESR_ALTVID_MASK; 537 if ((vid == 0) || (vid == FSL_CHASSIS3_DCFG_FUSESR_ALTVID_MASK)) { 538 vid = (fusesr >> FSL_CHASSIS3_DCFG_FUSESR_VID_SHIFT) & 539 FSL_CHASSIS3_DCFG_FUSESR_VID_MASK; 540 } 541 vdd_target = vdd[vid]; 542 543 /* check override variable for overriding VDD */ 544 vdd_string = env_get(CONFIG_VID_FLS_ENV); 545 if (vdd_override == 0 && vdd_string && 546 !strict_strtoul(vdd_string, 10, &vdd_string_override)) 547 vdd_override = vdd_string_override; 548 549 if (vdd_override >= VDD_MV_MIN && vdd_override <= VDD_MV_MAX) { 550 vdd_target = vdd_override * 10; /* convert to 1/10 mV */ 551 debug("VDD override is %lu\n", vdd_override); 552 } else if (vdd_override != 0) { 553 printf("Invalid value.\n"); 554 } 555 556 /* divide and round up by 10 to get a value in mV */ 557 vdd_target = DIV_ROUND_UP(vdd_target, 10); 558 if (vdd_target == 0) { 559 debug("VID: VID not used\n"); 560 ret = 0; 561 goto exit; 562 } else if (vdd_target < VDD_MV_MIN || vdd_target > VDD_MV_MAX) { 563 /* Check vdd_target is in valid range */ 564 printf("VID: Target VID %d mV is not in range.\n", 565 vdd_target); 566 ret = -1; 567 goto exit; 568 } else { 569 debug("VID: vid = %d mV\n", vdd_target); 570 } 571 572 /* 573 * Read voltage monitor to check real voltage. 574 */ 575 vdd_last = read_voltage(i2caddress); 576 if (vdd_last < 0) { 577 printf("VID: Couldn't read sensor abort VID adjustment\n"); 578 ret = -1; 579 goto exit; 580 } 581 vdd_current = vdd_last; 582 debug("VID: Core voltage is currently at %d mV\n", vdd_last); 583 584 #ifdef CONFIG_VOL_MONITOR_LTC3882_SET 585 /* Set the target voltage */ 586 vdd_last = vdd_current = set_voltage(i2caddress, vdd_target); 587 #else 588 /* 589 * Adjust voltage to at or one step above target. 590 * As measurements are less precise than setting the values 591 * we may run through dummy steps that cancel each other 592 * when stepping up and then down. 593 */ 594 while (vdd_last > 0 && 595 vdd_last < vdd_target) { 596 vdd_current += IR_VDD_STEP_UP; 597 vdd_last = set_voltage(i2caddress, vdd_current); 598 } 599 while (vdd_last > 0 && 600 vdd_last > vdd_target + (IR_VDD_STEP_DOWN - 1)) { 601 vdd_current -= IR_VDD_STEP_DOWN; 602 vdd_last = set_voltage(i2caddress, vdd_current); 603 } 604 605 #endif 606 if (board_adjust_vdd(vdd_target) < 0) { 607 ret = -1; 608 goto exit; 609 } 610 611 if (vdd_last > 0) 612 printf("VID: Core voltage after adjustment is at %d mV\n", 613 vdd_last); 614 else 615 ret = -1; 616 exit: 617 if (re_enable) 618 enable_interrupts(); 619 i2c_multiplexer_select_vid_channel(I2C_MUX_CH_DEFAULT); 620 return ret; 621 } 622 #else /* !CONFIG_FSL_LSCH3 */ 623 int adjust_vdd(ulong vdd_override) 624 { 625 int re_enable = disable_interrupts(); 626 #if defined(CONFIG_FSL_LSCH2) 627 struct ccsr_gur *gur = (void *)(CONFIG_SYS_FSL_GUTS_ADDR); 628 #else 629 ccsr_gur_t __iomem *gur = 630 (void __iomem *)(CONFIG_SYS_MPC85xx_GUTS_ADDR); 631 #endif 632 u32 fusesr; 633 u8 vid, buf; 634 int vdd_target, vdd_current, vdd_last; 635 int ret, i2caddress; 636 unsigned long vdd_string_override; 637 char *vdd_string; 638 static const uint16_t vdd[32] = { 639 0, /* unused */ 640 9875, /* 0.9875V */ 641 9750, 642 9625, 643 9500, 644 9375, 645 9250, 646 9125, 647 9000, 648 8875, 649 8750, 650 8625, 651 8500, 652 8375, 653 8250, 654 8125, 655 10000, /* 1.0000V */ 656 10125, 657 10250, 658 10375, 659 10500, 660 10625, 661 10750, 662 10875, 663 11000, 664 0, /* reserved */ 665 }; 666 struct vdd_drive { 667 u8 vid; 668 unsigned voltage; 669 }; 670 671 ret = i2c_multiplexer_select_vid_channel(I2C_MUX_CH_VOL_MONITOR); 672 if (ret) { 673 debug("VID: I2C failed to switch channel\n"); 674 ret = -1; 675 goto exit; 676 } 677 #if defined(CONFIG_VOL_MONITOR_IR36021_SET) || \ 678 defined(CONFIG_VOL_MONITOR_IR36021_READ) 679 ret = find_ir_chip_on_i2c(); 680 if (ret < 0) { 681 printf("VID: Could not find voltage regulator on I2C.\n"); 682 ret = -1; 683 goto exit; 684 } else { 685 i2caddress = ret; 686 debug("VID: IR Chip found on I2C address 0x%02x\n", i2caddress); 687 } 688 689 /* check IR chip work on Intel mode*/ 690 ret = i2c_read(i2caddress, 691 IR36021_INTEL_MODE_OOFSET, 692 1, (void *)&buf, 1); 693 if (ret) { 694 printf("VID: failed to read IR chip mode.\n"); 695 ret = -1; 696 goto exit; 697 } 698 if ((buf & IR36021_MODE_MASK) != IR36021_INTEL_MODE) { 699 printf("VID: IR Chip is not used in Intel mode.\n"); 700 ret = -1; 701 goto exit; 702 } 703 #endif 704 705 /* get the voltage ID from fuse status register */ 706 fusesr = in_be32(&gur->dcfg_fusesr); 707 /* 708 * VID is used according to the table below 709 * --------------------------------------- 710 * | DA_V | 711 * |-------------------------------------| 712 * | 5b00000 | 5b00001-5b11110 | 5b11111 | 713 * ---------------+---------+-----------------+---------| 714 * | D | 5b00000 | NO VID | VID = DA_V | NO VID | 715 * | A |----------+---------+-----------------+---------| 716 * | _ | 5b00001 |VID = | VID = |VID = | 717 * | V | ~ | DA_V_ALT| DA_V_ALT | DA_A_VLT| 718 * | _ | 5b11110 | | | | 719 * | A |----------+---------+-----------------+---------| 720 * | L | 5b11111 | No VID | VID = DA_V | NO VID | 721 * | T | | | | | 722 * ------------------------------------------------------ 723 */ 724 #ifdef CONFIG_FSL_LSCH2 725 vid = (fusesr >> FSL_CHASSIS2_DCFG_FUSESR_ALTVID_SHIFT) & 726 FSL_CHASSIS2_DCFG_FUSESR_ALTVID_MASK; 727 if ((vid == 0) || (vid == FSL_CHASSIS2_DCFG_FUSESR_ALTVID_MASK)) { 728 vid = (fusesr >> FSL_CHASSIS2_DCFG_FUSESR_VID_SHIFT) & 729 FSL_CHASSIS2_DCFG_FUSESR_VID_MASK; 730 } 731 #else 732 vid = (fusesr >> FSL_CORENET_DCFG_FUSESR_ALTVID_SHIFT) & 733 FSL_CORENET_DCFG_FUSESR_ALTVID_MASK; 734 if ((vid == 0) || (vid == FSL_CORENET_DCFG_FUSESR_ALTVID_MASK)) { 735 vid = (fusesr >> FSL_CORENET_DCFG_FUSESR_VID_SHIFT) & 736 FSL_CORENET_DCFG_FUSESR_VID_MASK; 737 } 738 #endif 739 vdd_target = vdd[vid]; 740 741 /* check override variable for overriding VDD */ 742 vdd_string = env_get(CONFIG_VID_FLS_ENV); 743 if (vdd_override == 0 && vdd_string && 744 !strict_strtoul(vdd_string, 10, &vdd_string_override)) 745 vdd_override = vdd_string_override; 746 if (vdd_override >= VDD_MV_MIN && vdd_override <= VDD_MV_MAX) { 747 vdd_target = vdd_override * 10; /* convert to 1/10 mV */ 748 debug("VDD override is %lu\n", vdd_override); 749 } else if (vdd_override != 0) { 750 printf("Invalid value.\n"); 751 } 752 if (vdd_target == 0) { 753 debug("VID: VID not used\n"); 754 ret = 0; 755 goto exit; 756 } else { 757 /* divide and round up by 10 to get a value in mV */ 758 vdd_target = DIV_ROUND_UP(vdd_target, 10); 759 debug("VID: vid = %d mV\n", vdd_target); 760 } 761 762 /* 763 * Read voltage monitor to check real voltage. 764 */ 765 vdd_last = read_voltage(i2caddress); 766 if (vdd_last < 0) { 767 printf("VID: Couldn't read sensor abort VID adjustment\n"); 768 ret = -1; 769 goto exit; 770 } 771 vdd_current = vdd_last; 772 debug("VID: Core voltage is currently at %d mV\n", vdd_last); 773 /* 774 * Adjust voltage to at or one step above target. 775 * As measurements are less precise than setting the values 776 * we may run through dummy steps that cancel each other 777 * when stepping up and then down. 778 */ 779 while (vdd_last > 0 && 780 vdd_last < vdd_target) { 781 vdd_current += IR_VDD_STEP_UP; 782 vdd_last = set_voltage(i2caddress, vdd_current); 783 } 784 while (vdd_last > 0 && 785 vdd_last > vdd_target + (IR_VDD_STEP_DOWN - 1)) { 786 vdd_current -= IR_VDD_STEP_DOWN; 787 vdd_last = set_voltage(i2caddress, vdd_current); 788 } 789 790 if (vdd_last > 0) 791 printf("VID: Core voltage after adjustment is at %d mV\n", 792 vdd_last); 793 else 794 ret = -1; 795 exit: 796 if (re_enable) 797 enable_interrupts(); 798 799 i2c_multiplexer_select_vid_channel(I2C_MUX_CH_DEFAULT); 800 801 return ret; 802 } 803 #endif 804 805 static int print_vdd(void) 806 { 807 int vdd_last, ret, i2caddress; 808 809 ret = i2c_multiplexer_select_vid_channel(I2C_MUX_CH_VOL_MONITOR); 810 if (ret) { 811 debug("VID : I2c failed to switch channel\n"); 812 return -1; 813 } 814 #if defined(CONFIG_VOL_MONITOR_IR36021_SET) || \ 815 defined(CONFIG_VOL_MONITOR_IR36021_READ) 816 ret = find_ir_chip_on_i2c(); 817 if (ret < 0) { 818 printf("VID: Could not find voltage regulator on I2C.\n"); 819 goto exit; 820 } else { 821 i2caddress = ret; 822 debug("VID: IR Chip found on I2C address 0x%02x\n", i2caddress); 823 } 824 #endif 825 826 /* 827 * Read voltage monitor to check real voltage. 828 */ 829 vdd_last = read_voltage(i2caddress); 830 if (vdd_last < 0) { 831 printf("VID: Couldn't read sensor abort VID adjustment\n"); 832 goto exit; 833 } 834 printf("VID: Core voltage is at %d mV\n", vdd_last); 835 exit: 836 i2c_multiplexer_select_vid_channel(I2C_MUX_CH_DEFAULT); 837 838 return ret < 0 ? -1 : 0; 839 840 } 841 842 static int do_vdd_override(cmd_tbl_t *cmdtp, 843 int flag, int argc, 844 char * const argv[]) 845 { 846 ulong override; 847 848 if (argc < 2) 849 return CMD_RET_USAGE; 850 851 if (!strict_strtoul(argv[1], 10, &override)) 852 adjust_vdd(override); /* the value is checked by callee */ 853 else 854 return CMD_RET_USAGE; 855 return 0; 856 } 857 858 static int do_vdd_read(cmd_tbl_t *cmdtp, 859 int flag, int argc, 860 char * const argv[]) 861 { 862 if (argc < 1) 863 return CMD_RET_USAGE; 864 print_vdd(); 865 866 return 0; 867 } 868 869 U_BOOT_CMD( 870 vdd_override, 2, 0, do_vdd_override, 871 "override VDD", 872 " - override with the voltage specified in mV, eg. 1050" 873 ); 874 875 U_BOOT_CMD( 876 vdd_read, 1, 0, do_vdd_read, 877 "read VDD", 878 " - Read the voltage specified in mV" 879 ) 880