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  * Get the i2c address configuration for the IR regulator chip
  38  *
  39  * There are some variance in the RDB HW regarding the I2C address configuration
  40  * for the IR regulator chip, which is likely a problem of external resistor
  41  * accuracy. So we just check each address in a hopefully non-intrusive mode
  42  * and use the first one that seems to work
  43  *
  44  * The IR chip can show up under the following addresses:
  45  * 0x08 (Verified on T1040RDB-PA,T4240RDB-PB,X-T4240RDB-16GPA)
  46  * 0x09 (Verified on T1040RDB-PA)
  47  * 0x38 (Verified on T2080QDS, T2081QDS, T4240RDB)
  48  */
  49 static int find_ir_chip_on_i2c(void)
  50 {
  51         int i2caddress;
  52         int ret;
  53         u8 byte;
  54         int i;
  55         const int ir_i2c_addr[] = {0x38, 0x08, 0x09};
  56
  57         /* Check all the address */
  58         for (i = 0; i < (sizeof(ir_i2c_addr)/sizeof(ir_i2c_addr[0])); i++) {
  59                 i2caddress = ir_i2c_addr[i];
  60                 ret = i2c_read(i2caddress,
  61                                IR36021_MFR_ID_OFFSET, 1, (void *)&byte,
  62                                sizeof(byte));
  63                 if ((ret >= 0) && (byte == IR36021_MFR_ID))
  64                         return i2caddress;
  65         }
  66         return -1;
  67 }
  68
  69 /* Maximum loop count waiting for new voltage to take effect */
  70 #define MAX_LOOP_WAIT_NEW_VOL           100
  71 /* Maximum loop count waiting for the voltage to be stable */
  72 #define MAX_LOOP_WAIT_VOL_STABLE        100
  73 /*
  74  * read_voltage from sensor on I2C bus
  75  * We use average of 4 readings, waiting for WAIT_FOR_ADC before
  76  * another reading
  77  */
  78 #define NUM_READINGS    4       /* prefer to be power of 2 for efficiency */
  79
  80 /* If an INA220 chip is available, we can use it to read back the voltage
  81  * as it may have a higher accuracy than the IR chip for the same purpose
  82  */
  83 #ifdef CONFIG_VOL_MONITOR_INA220
  84 #define WAIT_FOR_ADC    532     /* wait for 532 microseconds for ADC */
  85 #define ADC_MIN_ACCURACY        4
  86 #else
  87 #define WAIT_FOR_ADC    138     /* wait for 138 microseconds for ADC */
  88 #define ADC_MIN_ACCURACY        4
  89 #endif
  90
  91 #ifdef CONFIG_VOL_MONITOR_INA220
  92 static int read_voltage_from_INA220(int i2caddress)
  93 {
  94         int i, ret, voltage_read = 0;
  95         u16 vol_mon;
  96         u8 buf[2];
  97
  98         for (i = 0; i < NUM_READINGS; i++) {
  99                 ret = i2c_read(I2C_VOL_MONITOR_ADDR,
 100                                I2C_VOL_MONITOR_BUS_V_OFFSET, 1,
 101                                (void *)&buf, 2);
 102                 if (ret) {
 103                         printf("VID: failed to read core voltage\n");
 104                         return ret;
 105                 }
 106                 vol_mon = (buf[0] << 8) | buf[1];
 107                 if (vol_mon & I2C_VOL_MONITOR_BUS_V_OVF) {
 108                         printf("VID: Core voltage sensor error\n");
 109                         return -1;
 110                 }
 111                 debug("VID: bus voltage reads 0x%04x\n", vol_mon);
 112                 /* LSB = 4mv */
 113                 voltage_read += (vol_mon >> I2C_VOL_MONITOR_BUS_V_SHIFT) * 4;
 114                 udelay(WAIT_FOR_ADC);
 115         }
 116         /* calculate the average */
 117         voltage_read /= NUM_READINGS;
 118
 119         return voltage_read;
 120 }
 121 #endif
 122
 123 /* read voltage from IR */
 124 #ifdef CONFIG_VOL_MONITOR_IR36021_READ
 125 static int read_voltage_from_IR(int i2caddress)
 126 {
 127         int i, ret, voltage_read = 0;
 128         u16 vol_mon;
 129         u8 buf;
 130
 131         for (i = 0; i < NUM_READINGS; i++) {
 132                 ret = i2c_read(i2caddress,
 133                                IR36021_LOOP1_VOUT_OFFSET,
 134                                1, (void *)&buf, 1);
 135                 if (ret) {
 136                         printf("VID: failed to read vcpu\n");
 137                         return ret;
 138                 }
 139                 vol_mon = buf;
 140                 if (!vol_mon) {
 141                         printf("VID: Core voltage sensor error\n");
 142                         return -1;
 143                 }
 144                 debug("VID: bus voltage reads 0x%02x\n", vol_mon);
 145                 /* Resolution is 1/128V. We scale up here to get 1/128mV
 146                  * and divide at the end
 147                  */
 148                 voltage_read += vol_mon * 1000;
 149                 udelay(WAIT_FOR_ADC);
 150         }
 151         /* Scale down to the real mV as IR resolution is 1/128V, rounding up */
 152         voltage_read = DIV_ROUND_UP(voltage_read, 128);
 153
 154         /* calculate the average */
 155         voltage_read /= NUM_READINGS;
 156
 157         /* Compensate for a board specific voltage drop between regulator and
 158          * SoC before converting into an IR VID value
 159          */
 160         voltage_read -= board_vdd_drop_compensation();
 161
 162         return voltage_read;
 163 }
 164 #endif
 165
 166 static int read_voltage(int i2caddress)
 167 {
 168         int voltage_read;
 169 #ifdef CONFIG_VOL_MONITOR_INA220
 170         voltage_read = read_voltage_from_INA220(i2caddress);
 171 #elif defined CONFIG_VOL_MONITOR_IR36021_READ
 172         voltage_read = read_voltage_from_IR(i2caddress);
 173 #else
 174         return -1;
 175 #endif
 176         return voltage_read;
 177 }
 178
 179 /*
 180  * We need to calculate how long before the voltage stops to drop
 181  * or increase. It returns with the loop count. Each loop takes
 182  * several readings (WAIT_FOR_ADC)
 183  */
 184 static int wait_for_new_voltage(int vdd, int i2caddress)
 185 {
 186         int timeout, vdd_current;
 187
 188         vdd_current = read_voltage(i2caddress);
 189         /* wait until voltage starts to reach the target. Voltage slew
 190          * rates by typical regulators will always lead to stable readings
 191          * within each fairly long ADC interval in comparison to the
 192          * intended voltage delta change until the target voltage is
 193          * reached. The fairly small voltage delta change to any target
 194          * VID voltage also means that this function will always complete
 195          * within few iterations. If the timeout was ever reached, it would
 196          * point to a serious failure in the regulator system.
 197          */
 198         for (timeout = 0;
 199              abs(vdd - vdd_current) > (IR_VDD_STEP_UP + IR_VDD_STEP_DOWN) &&
 200              timeout < MAX_LOOP_WAIT_NEW_VOL; timeout++) {
 201                 vdd_current = read_voltage(i2caddress);
 202         }
 203         if (timeout >= MAX_LOOP_WAIT_NEW_VOL) {
 204                 printf("VID: Voltage adjustment timeout\n");
 205                 return -1;
 206         }
 207         return timeout;
 208 }
 209
 210 /*
 211  * this function keeps reading the voltage until it is stable or until the
 212  * timeout expires
 213  */
 214 static int wait_for_voltage_stable(int i2caddress)
 215 {
 216         int timeout, vdd_current, vdd;
 217
 218         vdd = read_voltage(i2caddress);
 219         udelay(NUM_READINGS * WAIT_FOR_ADC);
 220
 221         /* wait until voltage is stable */
 222         vdd_current = read_voltage(i2caddress);
 223         /* The maximum timeout is
 224          * MAX_LOOP_WAIT_VOL_STABLE * NUM_READINGS * WAIT_FOR_ADC
 225          */
 226         for (timeout = MAX_LOOP_WAIT_VOL_STABLE;
 227              abs(vdd - vdd_current) > ADC_MIN_ACCURACY &&
 228              timeout > 0; timeout--) {
 229                 vdd = vdd_current;
 230                 udelay(NUM_READINGS * WAIT_FOR_ADC);
 231                 vdd_current = read_voltage(i2caddress);
 232         }
 233         if (timeout == 0)
 234                 return -1;
 235         return vdd_current;
 236 }
 237
 238 #ifdef CONFIG_VOL_MONITOR_IR36021_SET
 239 /* Set the voltage to the IR chip */
 240 static int set_voltage_to_IR(int i2caddress, int vdd)
 241 {
 242         int wait, vdd_last;
 243         int ret;
 244         u8 vid;
 245
 246         /* Compensate for a board specific voltage drop between regulator and
 247          * SoC before converting into an IR VID value
 248          */
 249         vdd += board_vdd_drop_compensation();
 250 #ifdef CONFIG_FSL_LSCH2
 251         vid = DIV_ROUND_UP(vdd - 265, 5);
 252 #else
 253         vid = DIV_ROUND_UP(vdd - 245, 5);
 254 #endif
 255
 256         ret = i2c_write(i2caddress, IR36021_LOOP1_MANUAL_ID_OFFSET,
 257                         1, (void *)&vid, sizeof(vid));
 258         if (ret) {
 259                 printf("VID: failed to write VID\n");
 260                 return -1;
 261         }
 262         wait = wait_for_new_voltage(vdd, i2caddress);
 263         if (wait < 0)
 264                 return -1;
 265         debug("VID: Waited %d us\n", wait * NUM_READINGS * WAIT_FOR_ADC);
 266
 267         vdd_last = wait_for_voltage_stable(i2caddress);
 268         if (vdd_last < 0)
 269                 return -1;
 270         debug("VID: Current voltage is %d mV\n", vdd_last);
 271         return vdd_last;
 272 }
 273 #endif
 274
 275 static int set_voltage(int i2caddress, int vdd)
 276 {
 277         int vdd_last = -1;
 278
 279 #ifdef CONFIG_VOL_MONITOR_IR36021_SET
 280         vdd_last = set_voltage_to_IR(i2caddress, vdd);
 281 #else
 282         #error Specific voltage monitor must be defined
 283 #endif
 284         return vdd_last;
 285 }
 286
 287 #ifdef CONFIG_FSL_LSCH3
 288 int adjust_vdd(ulong vdd_override)
 289 {
 290         int re_enable = disable_interrupts();
 291         struct ccsr_gur *gur = (void *)(CONFIG_SYS_FSL_GUTS_ADDR);
 292         u32 fusesr;
 293         u8 vid, buf;
 294         int vdd_target, vdd_current, vdd_last;
 295         int ret, i2caddress;
 296         unsigned long vdd_string_override;
 297         char *vdd_string;
 298         static const uint16_t vdd[32] = {
 299                 10500,
 300                 0,      /* reserved */
 301                 9750,
 302                 0,      /* reserved */
 303                 9500,
 304                 0,      /* reserved */
 305                 0,      /* reserved */
 306                 0,      /* reserved */
 307                 0,      /* reserved */
 308                 0,      /* reserved */
 309                 0,      /* reserved */
 310                 0,      /* reserved */
 311                 0,      /* reserved */
 312                 0,      /* reserved */
 313                 0,      /* reserved */
 314                 0,      /* reserved */
 315                 10000,  /* 1.0000V */
 316                 0,      /* reserved */
 317                 10250,
 318                 0,      /* reserved */
 319                 10500,
 320                 0,      /* reserved */
 321                 0,      /* reserved */
 322                 0,      /* reserved */
 323                 0,      /* reserved */
 324                 0,      /* reserved */
 325                 0,      /* reserved */
 326                 0,      /* reserved */
 327                 0,      /* reserved */
 328                 0,      /* reserved */
 329                 0,      /* reserved */
 330                 0,      /* reserved */
 331         };
 332         struct vdd_drive {
 333                 u8 vid;
 334                 unsigned voltage;
 335         };
 336
 337         ret = i2c_multiplexer_select_vid_channel(I2C_MUX_CH_VOL_MONITOR);
 338         if (ret) {
 339                 debug("VID: I2C failed to switch channel\n");
 340                 ret = -1;
 341                 goto exit;
 342         }
 343         ret = find_ir_chip_on_i2c();
 344         if (ret < 0) {
 345                 printf("VID: Could not find voltage regulator on I2C.\n");
 346                 ret = -1;
 347                 goto exit;
 348         } else {
 349                 i2caddress = ret;
 350                 debug("VID: IR Chip found on I2C address 0x%02x\n", i2caddress);
 351         }
 352
 353         /* check IR chip work on Intel mode*/
 354         ret = i2c_read(i2caddress,
 355                        IR36021_INTEL_MODE_OOFSET,
 356                        1, (void *)&buf, 1);
 357         if (ret) {
 358                 printf("VID: failed to read IR chip mode.\n");
 359                 ret = -1;
 360                 goto exit;
 361         }
 362         if ((buf & IR36021_MODE_MASK) != IR36021_INTEL_MODE) {
 363                 printf("VID: IR Chip is not used in Intel mode.\n");
 364                 ret = -1;
 365                 goto exit;
 366         }
 367
 368         /* get the voltage ID from fuse status register */
 369         fusesr = in_le32(&gur->dcfg_fusesr);
 370         vid = (fusesr >> FSL_CHASSIS3_DCFG_FUSESR_ALTVID_SHIFT) &
 371                 FSL_CHASSIS3_DCFG_FUSESR_ALTVID_MASK;
 372         if ((vid == 0) || (vid == FSL_CHASSIS3_DCFG_FUSESR_ALTVID_MASK)) {
 373                 vid = (fusesr >> FSL_CHASSIS3_DCFG_FUSESR_VID_SHIFT) &
 374                         FSL_CHASSIS3_DCFG_FUSESR_VID_MASK;
 375         }
 376         vdd_target = vdd[vid];
 377
 378         /* check override variable for overriding VDD */
 379         vdd_string = getenv(CONFIG_VID_FLS_ENV);
 380         if (vdd_override == 0 && vdd_string &&
 381             !strict_strtoul(vdd_string, 10, &vdd_string_override))
 382                 vdd_override = vdd_string_override;
 383
 384         if (vdd_override >= VDD_MV_MIN && vdd_override <= VDD_MV_MAX) {
 385                 vdd_target = vdd_override * 10; /* convert to 1/10 mV */
 386                 debug("VDD override is %lu\n", vdd_override);
 387         } else if (vdd_override != 0) {
 388                 printf("Invalid value.\n");
 389         }
 390
 391         /* divide and round up by 10 to get a value in mV */
 392         vdd_target = DIV_ROUND_UP(vdd_target, 10);
 393         if (vdd_target == 0) {
 394                 debug("VID: VID not used\n");
 395                 ret = 0;
 396                 goto exit;
 397         } else if (vdd_target < VDD_MV_MIN || vdd_target > VDD_MV_MAX) {
 398                 /* Check vdd_target is in valid range */
 399                 printf("VID: Target VID %d mV is not in range.\n",
 400                        vdd_target);
 401                 ret = -1;
 402                 goto exit;
 403         } else {
 404                 debug("VID: vid = %d mV\n", vdd_target);
 405         }
 406
 407         /*
 408          * Read voltage monitor to check real voltage.
 409          */
 410         vdd_last = read_voltage(i2caddress);
 411         if (vdd_last < 0) {
 412                 printf("VID: Couldn't read sensor abort VID adjustment\n");
 413                 ret = -1;
 414                 goto exit;
 415         }
 416         vdd_current = vdd_last;
 417         debug("VID: Core voltage is currently at %d mV\n", vdd_last);
 418         /*
 419           * Adjust voltage to at or one step above target.
 420           * As measurements are less precise than setting the values
 421           * we may run through dummy steps that cancel each other
 422           * when stepping up and then down.
 423           */
 424         while (vdd_last > 0 &&
 425                vdd_last < vdd_target) {
 426                 vdd_current += IR_VDD_STEP_UP;
 427                 vdd_last = set_voltage(i2caddress, vdd_current);
 428         }
 429         while (vdd_last > 0 &&
 430                vdd_last > vdd_target + (IR_VDD_STEP_DOWN - 1)) {
 431                 vdd_current -= IR_VDD_STEP_DOWN;
 432                 vdd_last = set_voltage(i2caddress, vdd_current);
 433         }
 434
 435         if (vdd_last > 0)
 436                 printf("VID: Core voltage after adjustment is at %d mV\n",
 437                        vdd_last);
 438         else
 439                 ret = -1;
 440 exit:
 441         if (re_enable)
 442                 enable_interrupts();
 443         i2c_multiplexer_select_vid_channel(I2C_MUX_CH_DEFAULT);
 444         return ret;
 445 }
 446 #else /* !CONFIG_FSL_LSCH3 */
 447 int adjust_vdd(ulong vdd_override)
 448 {
 449         int re_enable = disable_interrupts();
 450 #if defined(CONFIG_FSL_LSCH2)
 451         struct ccsr_gur *gur = (void *)(CONFIG_SYS_FSL_GUTS_ADDR);
 452 #else
 453         ccsr_gur_t __iomem *gur =
 454                 (void __iomem *)(CONFIG_SYS_MPC85xx_GUTS_ADDR);
 455 #endif
 456         u32 fusesr;
 457         u8 vid, buf;
 458         int vdd_target, vdd_current, vdd_last;
 459         int ret, i2caddress;
 460         unsigned long vdd_string_override;
 461         char *vdd_string;
 462         static const uint16_t vdd[32] = {
 463                 0,      /* unused */
 464                 9875,   /* 0.9875V */
 465                 9750,
 466                 9625,
 467                 9500,
 468                 9375,
 469                 9250,
 470                 9125,
 471                 9000,
 472                 8875,
 473                 8750,
 474                 8625,
 475                 8500,
 476                 8375,
 477                 8250,
 478                 8125,
 479                 10000,  /* 1.0000V */
 480                 10125,
 481                 10250,
 482                 10375,
 483                 10500,
 484                 10625,
 485                 10750,
 486                 10875,
 487                 11000,
 488                 0,      /* reserved */
 489         };
 490         struct vdd_drive {
 491                 u8 vid;
 492                 unsigned voltage;
 493         };
 494
 495         ret = i2c_multiplexer_select_vid_channel(I2C_MUX_CH_VOL_MONITOR);
 496         if (ret) {
 497                 debug("VID: I2C failed to switch channel\n");
 498                 ret = -1;
 499                 goto exit;
 500         }
 501         ret = find_ir_chip_on_i2c();
 502         if (ret < 0) {
 503                 printf("VID: Could not find voltage regulator on I2C.\n");
 504                 ret = -1;
 505                 goto exit;
 506         } else {
 507                 i2caddress = ret;
 508                 debug("VID: IR Chip found on I2C address 0x%02x\n", i2caddress);
 509         }
 510
 511         /* check IR chip work on Intel mode*/
 512         ret = i2c_read(i2caddress,
 513                        IR36021_INTEL_MODE_OOFSET,
 514                        1, (void *)&buf, 1);
 515         if (ret) {
 516                 printf("VID: failed to read IR chip mode.\n");
 517                 ret = -1;
 518                 goto exit;
 519         }
 520         if ((buf & IR36021_MODE_MASK) != IR36021_INTEL_MODE) {
 521                 printf("VID: IR Chip is not used in Intel mode.\n");
 522                 ret = -1;
 523                 goto exit;
 524         }
 525
 526         /* get the voltage ID from fuse status register */
 527         fusesr = in_be32(&gur->dcfg_fusesr);
 528         /*
 529          * VID is used according to the table below
 530          *                ---------------------------------------
 531          *                |                DA_V                 |
 532          *                |-------------------------------------|
 533          *                | 5b00000 | 5b00001-5b11110 | 5b11111 |
 534          * ---------------+---------+-----------------+---------|
 535          * | D | 5b00000  | NO VID  | VID = DA_V      | NO VID  |
 536          * | A |----------+---------+-----------------+---------|
 537          * | _ | 5b00001  |VID =    | VID =           |VID =    |
 538          * | V |   ~      | DA_V_ALT|   DA_V_ALT      | DA_A_VLT|
 539          * | _ | 5b11110  |         |                 |         |
 540          * | A |----------+---------+-----------------+---------|
 541          * | L | 5b11111  | No VID  | VID = DA_V      | NO VID  |
 542          * | T |          |         |                 |         |
 543          * ------------------------------------------------------
 544          */
 545 #ifdef CONFIG_FSL_LSCH2
 546         vid = (fusesr >> FSL_CHASSIS2_DCFG_FUSESR_ALTVID_SHIFT) &
 547                 FSL_CHASSIS2_DCFG_FUSESR_ALTVID_MASK;
 548         if ((vid == 0) || (vid == FSL_CHASSIS2_DCFG_FUSESR_ALTVID_MASK)) {
 549                 vid = (fusesr >> FSL_CHASSIS2_DCFG_FUSESR_VID_SHIFT) &
 550                         FSL_CHASSIS2_DCFG_FUSESR_VID_MASK;
 551         }
 552 #else
 553         vid = (fusesr >> FSL_CORENET_DCFG_FUSESR_ALTVID_SHIFT) &
 554                 FSL_CORENET_DCFG_FUSESR_ALTVID_MASK;
 555         if ((vid == 0) || (vid == FSL_CORENET_DCFG_FUSESR_ALTVID_MASK)) {
 556                 vid = (fusesr >> FSL_CORENET_DCFG_FUSESR_VID_SHIFT) &
 557                         FSL_CORENET_DCFG_FUSESR_VID_MASK;
 558         }
 559 #endif
 560         vdd_target = vdd[vid];
 561
 562         /* check override variable for overriding VDD */
 563         vdd_string = getenv(CONFIG_VID_FLS_ENV);
 564         if (vdd_override == 0 && vdd_string &&
 565             !strict_strtoul(vdd_string, 10, &vdd_string_override))
 566                 vdd_override = vdd_string_override;
 567         if (vdd_override >= VDD_MV_MIN && vdd_override <= VDD_MV_MAX) {
 568                 vdd_target = vdd_override * 10; /* convert to 1/10 mV */
 569                 debug("VDD override is %lu\n", vdd_override);
 570         } else if (vdd_override != 0) {
 571                 printf("Invalid value.\n");
 572         }
 573         if (vdd_target == 0) {
 574                 debug("VID: VID not used\n");
 575                 ret = 0;
 576                 goto exit;
 577         } else {
 578                 /* divide and round up by 10 to get a value in mV */
 579                 vdd_target = DIV_ROUND_UP(vdd_target, 10);
 580                 debug("VID: vid = %d mV\n", vdd_target);
 581         }
 582
 583         /*
 584          * Read voltage monitor to check real voltage.
 585          */
 586         vdd_last = read_voltage(i2caddress);
 587         if (vdd_last < 0) {
 588                 printf("VID: Couldn't read sensor abort VID adjustment\n");
 589                 ret = -1;
 590                 goto exit;
 591         }
 592         vdd_current = vdd_last;
 593         debug("VID: Core voltage is currently at %d mV\n", vdd_last);
 594         /*
 595           * Adjust voltage to at or one step above target.
 596           * As measurements are less precise than setting the values
 597           * we may run through dummy steps that cancel each other
 598           * when stepping up and then down.
 599           */
 600         while (vdd_last > 0 &&
 601                vdd_last < vdd_target) {
 602                 vdd_current += IR_VDD_STEP_UP;
 603                 vdd_last = set_voltage(i2caddress, vdd_current);
 604         }
 605         while (vdd_last > 0 &&
 606                vdd_last > vdd_target + (IR_VDD_STEP_DOWN - 1)) {
 607                 vdd_current -= IR_VDD_STEP_DOWN;
 608                 vdd_last = set_voltage(i2caddress, vdd_current);
 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
 620         i2c_multiplexer_select_vid_channel(I2C_MUX_CH_DEFAULT);
 621
 622         return ret;
 623 }
 624 #endif
 625
 626 static int print_vdd(void)
 627 {
 628         int vdd_last, ret, i2caddress;
 629
 630         ret = i2c_multiplexer_select_vid_channel(I2C_MUX_CH_VOL_MONITOR);
 631         if (ret) {
 632                 debug("VID : I2c failed to switch channel\n");
 633                 return -1;
 634         }
 635         ret = find_ir_chip_on_i2c();
 636         if (ret < 0) {
 637                 printf("VID: Could not find voltage regulator on I2C.\n");
 638                 goto exit;
 639         } else {
 640                 i2caddress = ret;
 641                 debug("VID: IR Chip found on I2C address 0x%02x\n", i2caddress);
 642         }
 643
 644         /*
 645          * Read voltage monitor to check real voltage.
 646          */
 647         vdd_last = read_voltage(i2caddress);
 648         if (vdd_last < 0) {
 649                 printf("VID: Couldn't read sensor abort VID adjustment\n");
 650                 goto exit;
 651         }
 652         printf("VID: Core voltage is at %d mV\n", vdd_last);
 653 exit:
 654         i2c_multiplexer_select_vid_channel(I2C_MUX_CH_DEFAULT);
 655
 656         return ret < 0 ? -1 : 0;
 657
 658 }
 659
 660 static int do_vdd_override(cmd_tbl_t *cmdtp,
 661                            int flag, int argc,
 662                            char * const argv[])
 663 {
 664         ulong override;
 665
 666         if (argc < 2)
 667                 return CMD_RET_USAGE;
 668
 669         if (!strict_strtoul(argv[1], 10, &override))
 670                 adjust_vdd(override);   /* the value is checked by callee */
 671         else
 672                 return CMD_RET_USAGE;
 673         return 0;
 674 }
 675
 676 static int do_vdd_read(cmd_tbl_t *cmdtp,
 677                          int flag, int argc,
 678                          char * const argv[])
 679 {
 680         if (argc < 1)
 681                 return CMD_RET_USAGE;
 682         print_vdd();
 683
 684         return 0;
 685 }
 686
 687 U_BOOT_CMD(
 688         vdd_override, 2, 0, do_vdd_override,
 689         "override VDD",
 690         " - override with the voltage specified in mV, eg. 1050"
 691 );
 692
 693 U_BOOT_CMD(
 694         vdd_read, 1, 0, do_vdd_read,
 695         "read VDD",
 696         " - Read the voltage specified in mV"
 697 )