git.sur5r.net Git - u-boot/blob - board/freescale/common/vid.c

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