board/freescale/common/vid.c

   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
 322         /* Scale up to the LTC resolution is 1/4096V */
 323         vdd = (vdd * 4096) / 1000;
 324
 325         /* 5-byte buffer which needs to be sent following the
 326          * PMBus command PAGE_PLUS_WRITE.
 327          */
 328         u8 buff[5] = {0x04, PWM_CHANNEL0, PMBUS_CMD_VOUT_COMMAND,
 329                         vdd & 0xFF, (vdd & 0xFF00) >> 8};
 330
 331         /* Write the desired voltage code to the regulator */
 332         ret = i2c_write(I2C_VOL_MONITOR_ADDR,
 333                         PMBUS_CMD_PAGE_PLUS_WRITE, 1, (void *)&buff, 5);
 334         if (ret) {
 335                 printf("VID: I2C failed to write to the volatge regulator\n");
 336                 return -1;
 337         }
 338
 339         /* Wait for the volatge to get to the desired value */
 340         do {
 341                 vdd_last = read_voltage_from_LTC(i2caddress);
 342                 if (vdd_last < 0) {
 343                         printf("VID: Couldn't read sensor abort VID adjust\n");
 344                         return -1;
 345                 }
 346         } while (vdd_last != vdd_target);
 347
 348         return vdd_last;
 349 }
 350 #endif
 351
 352 static int set_voltage(int i2caddress, int vdd)
 353 {
 354         int vdd_last = -1;
 355
 356 #ifdef CONFIG_VOL_MONITOR_IR36021_SET
 357         vdd_last = set_voltage_to_IR(i2caddress, vdd);
 358 #elif defined CONFIG_VOL_MONITOR_LTC3882_SET
 359         vdd_last = set_voltage_to_LTC(i2caddress, vdd);
 360 #else
 361         #error Specific voltage monitor must be defined
 362 #endif
 363         return vdd_last;
 364 }
 365
 366 #ifdef CONFIG_FSL_LSCH3
 367 int adjust_vdd(ulong vdd_override)
 368 {
 369         int re_enable = disable_interrupts();
 370         struct ccsr_gur *gur = (void *)(CONFIG_SYS_FSL_GUTS_ADDR);
 371         u32 fusesr;
 372 #if defined(CONFIG_VOL_MONITOR_IR36021_SET) || \
 373         defined(CONFIG_VOL_MONITOR_IR36021_READ)
 374         u8 vid, buf;
 375 #else
 376         u8 vid;
 377 #endif
 378         int vdd_target, vdd_current, vdd_last;
 379         int ret, i2caddress;
 380         unsigned long vdd_string_override;
 381         char *vdd_string;
 382 #ifdef CONFIG_ARCH_LS1088A
 383         static const uint16_t vdd[32] = {
 384                 10250,
 385                 9875,
 386                 9750,
 387                 0,      /* reserved */
 388                 0,      /* reserved */
 389                 0,      /* reserved */
 390                 0,      /* reserved */
 391                 0,      /* reserved */
 392                 9000,
 393                 0,      /* reserved */
 394                 0,      /* reserved */
 395                 0,      /* reserved */
 396                 0,      /* reserved */
 397                 0,      /* reserved */
 398                 0,      /* reserved */
 399                 0,      /* reserved */
 400                 10000,  /* 1.0000V */
 401                 10125,
 402                 10250,
 403                 0,      /* reserved */
 404                 0,      /* reserved */
 405                 0,      /* reserved */
 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         };
 417
 418 #else
 419         static const uint16_t vdd[32] = {
 420                 10500,
 421                 0,      /* reserved */
 422                 9750,
 423                 0,      /* reserved */
 424                 9500,
 425                 0,      /* reserved */
 426                 0,      /* reserved */
 427                 0,      /* reserved */
 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                 10000,  /* 1.0000V */
 437                 0,      /* reserved */
 438                 10250,
 439                 0,      /* reserved */
 440                 10500,
 441                 0,      /* reserved */
 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         };
 453 #endif
 454         struct vdd_drive {
 455                 u8 vid;
 456                 unsigned voltage;
 457         };
 458
 459         ret = i2c_multiplexer_select_vid_channel(I2C_MUX_CH_VOL_MONITOR);
 460         if (ret) {
 461                 debug("VID: I2C failed to switch channel\n");
 462                 ret = -1;
 463                 goto exit;
 464         }
 465 #if defined(CONFIG_VOL_MONITOR_IR36021_SET) || \
 466         defined(CONFIG_VOL_MONITOR_IR36021_READ)
 467         ret = find_ir_chip_on_i2c();
 468         if (ret < 0) {
 469                 printf("VID: Could not find voltage regulator on I2C.\n");
 470                 ret = -1;
 471                 goto exit;
 472         } else {
 473                 i2caddress = ret;
 474                 debug("VID: IR Chip found on I2C address 0x%02x\n", i2caddress);
 475         }
 476
 477         /* check IR chip work on Intel mode*/
 478         ret = i2c_read(i2caddress,
 479                        IR36021_INTEL_MODE_OOFSET,
 480                        1, (void *)&buf, 1);
 481         if (ret) {
 482                 printf("VID: failed to read IR chip mode.\n");
 483                 ret = -1;
 484                 goto exit;
 485         }
 486         if ((buf & IR36021_MODE_MASK) != IR36021_INTEL_MODE) {
 487                 printf("VID: IR Chip is not used in Intel mode.\n");
 488                 ret = -1;
 489                 goto exit;
 490         }
 491 #endif
 492
 493         /* get the voltage ID from fuse status register */
 494         fusesr = in_le32(&gur->dcfg_fusesr);
 495         vid = (fusesr >> FSL_CHASSIS3_DCFG_FUSESR_ALTVID_SHIFT) &
 496                 FSL_CHASSIS3_DCFG_FUSESR_ALTVID_MASK;
 497         if ((vid == 0) || (vid == FSL_CHASSIS3_DCFG_FUSESR_ALTVID_MASK)) {
 498                 vid = (fusesr >> FSL_CHASSIS3_DCFG_FUSESR_VID_SHIFT) &
 499                         FSL_CHASSIS3_DCFG_FUSESR_VID_MASK;
 500         }
 501         vdd_target = vdd[vid];
 502
 503         /* check override variable for overriding VDD */
 504         vdd_string = env_get(CONFIG_VID_FLS_ENV);
 505         if (vdd_override == 0 && vdd_string &&
 506             !strict_strtoul(vdd_string, 10, &vdd_string_override))
 507                 vdd_override = vdd_string_override;
 508
 509         if (vdd_override >= VDD_MV_MIN && vdd_override <= VDD_MV_MAX) {
 510                 vdd_target = vdd_override * 10; /* convert to 1/10 mV */
 511                 debug("VDD override is %lu\n", vdd_override);
 512         } else if (vdd_override != 0) {
 513                 printf("Invalid value.\n");
 514         }
 515
 516         /* divide and round up by 10 to get a value in mV */
 517         vdd_target = DIV_ROUND_UP(vdd_target, 10);
 518         if (vdd_target == 0) {
 519                 debug("VID: VID not used\n");
 520                 ret = 0;
 521                 goto exit;
 522         } else if (vdd_target < VDD_MV_MIN || vdd_target > VDD_MV_MAX) {
 523                 /* Check vdd_target is in valid range */
 524                 printf("VID: Target VID %d mV is not in range.\n",
 525                        vdd_target);
 526                 ret = -1;
 527                 goto exit;
 528         } else {
 529                 debug("VID: vid = %d mV\n", vdd_target);
 530         }
 531
 532         /*
 533          * Read voltage monitor to check real voltage.
 534          */
 535         vdd_last = read_voltage(i2caddress);
 536         if (vdd_last < 0) {
 537                 printf("VID: Couldn't read sensor abort VID adjustment\n");
 538                 ret = -1;
 539                 goto exit;
 540         }
 541         vdd_current = vdd_last;
 542         debug("VID: Core voltage is currently at %d mV\n", vdd_last);
 543
 544 #ifdef CONFIG_VOL_MONITOR_LTC3882_SET
 545         /* Set the target voltage */
 546         vdd_last = vdd_current = set_voltage(i2caddress, vdd_target);
 547 #else
 548         /*
 549           * Adjust voltage to at or one step above target.
 550           * As measurements are less precise than setting the values
 551           * we may run through dummy steps that cancel each other
 552           * when stepping up and then down.
 553           */
 554         while (vdd_last > 0 &&
 555                vdd_last < vdd_target) {
 556                 vdd_current += IR_VDD_STEP_UP;
 557                 vdd_last = set_voltage(i2caddress, vdd_current);
 558         }
 559         while (vdd_last > 0 &&
 560                vdd_last > vdd_target + (IR_VDD_STEP_DOWN - 1)) {
 561                 vdd_current -= IR_VDD_STEP_DOWN;
 562                 vdd_last = set_voltage(i2caddress, vdd_current);
 563         }
 564
 565 #endif
 566         if (board_adjust_vdd(vdd_target) < 0) {
 567                 ret = -1;
 568                 goto exit;
 569         }
 570
 571         if (vdd_last > 0)
 572                 printf("VID: Core voltage after adjustment is at %d mV\n",
 573                        vdd_last);
 574         else
 575                 ret = -1;
 576 exit:
 577         if (re_enable)
 578                 enable_interrupts();
 579         i2c_multiplexer_select_vid_channel(I2C_MUX_CH_DEFAULT);
 580         return ret;
 581 }
 582 #else /* !CONFIG_FSL_LSCH3 */
 583 int adjust_vdd(ulong vdd_override)
 584 {
 585         int re_enable = disable_interrupts();
 586 #if defined(CONFIG_FSL_LSCH2)
 587         struct ccsr_gur *gur = (void *)(CONFIG_SYS_FSL_GUTS_ADDR);
 588 #else
 589         ccsr_gur_t __iomem *gur =
 590                 (void __iomem *)(CONFIG_SYS_MPC85xx_GUTS_ADDR);
 591 #endif
 592         u32 fusesr;
 593         u8 vid, buf;
 594         int vdd_target, vdd_current, vdd_last;
 595         int ret, i2caddress;
 596         unsigned long vdd_string_override;
 597         char *vdd_string;
 598         static const uint16_t vdd[32] = {
 599                 0,      /* unused */
 600                 9875,   /* 0.9875V */
 601                 9750,
 602                 9625,
 603                 9500,
 604                 9375,
 605                 9250,
 606                 9125,
 607                 9000,
 608                 8875,
 609                 8750,
 610                 8625,
 611                 8500,
 612                 8375,
 613                 8250,
 614                 8125,
 615                 10000,  /* 1.0000V */
 616                 10125,
 617                 10250,
 618                 10375,
 619                 10500,
 620                 10625,
 621                 10750,
 622                 10875,
 623                 11000,
 624                 0,      /* reserved */
 625         };
 626         struct vdd_drive {
 627                 u8 vid;
 628                 unsigned voltage;
 629         };
 630
 631         ret = i2c_multiplexer_select_vid_channel(I2C_MUX_CH_VOL_MONITOR);
 632         if (ret) {
 633                 debug("VID: I2C failed to switch channel\n");
 634                 ret = -1;
 635                 goto exit;
 636         }
 637 #if defined(CONFIG_VOL_MONITOR_IR36021_SET) || \
 638         defined(CONFIG_VOL_MONITOR_IR36021_READ)
 639         ret = find_ir_chip_on_i2c();
 640         if (ret < 0) {
 641                 printf("VID: Could not find voltage regulator on I2C.\n");
 642                 ret = -1;
 643                 goto exit;
 644         } else {
 645                 i2caddress = ret;
 646                 debug("VID: IR Chip found on I2C address 0x%02x\n", i2caddress);
 647         }
 648
 649         /* check IR chip work on Intel mode*/
 650         ret = i2c_read(i2caddress,
 651                        IR36021_INTEL_MODE_OOFSET,
 652                        1, (void *)&buf, 1);
 653         if (ret) {
 654                 printf("VID: failed to read IR chip mode.\n");
 655                 ret = -1;
 656                 goto exit;
 657         }
 658         if ((buf & IR36021_MODE_MASK) != IR36021_INTEL_MODE) {
 659                 printf("VID: IR Chip is not used in Intel mode.\n");
 660                 ret = -1;
 661                 goto exit;
 662         }
 663 #endif
 664
 665         /* get the voltage ID from fuse status register */
 666         fusesr = in_be32(&gur->dcfg_fusesr);
 667         /*
 668          * VID is used according to the table below
 669          *                ---------------------------------------
 670          *                |                DA_V                 |
 671          *                |-------------------------------------|
 672          *                | 5b00000 | 5b00001-5b11110 | 5b11111 |
 673          * ---------------+---------+-----------------+---------|
 674          * | D | 5b00000  | NO VID  | VID = DA_V      | NO VID  |
 675          * | A |----------+---------+-----------------+---------|
 676          * | _ | 5b00001  |VID =    | VID =           |VID =    |
 677          * | V |   ~      | DA_V_ALT|   DA_V_ALT      | DA_A_VLT|
 678          * | _ | 5b11110  |         |                 |         |
 679          * | A |----------+---------+-----------------+---------|
 680          * | L | 5b11111  | No VID  | VID = DA_V      | NO VID  |
 681          * | T |          |         |                 |         |
 682          * ------------------------------------------------------
 683          */
 684 #ifdef CONFIG_FSL_LSCH2
 685         vid = (fusesr >> FSL_CHASSIS2_DCFG_FUSESR_ALTVID_SHIFT) &
 686                 FSL_CHASSIS2_DCFG_FUSESR_ALTVID_MASK;
 687         if ((vid == 0) || (vid == FSL_CHASSIS2_DCFG_FUSESR_ALTVID_MASK)) {
 688                 vid = (fusesr >> FSL_CHASSIS2_DCFG_FUSESR_VID_SHIFT) &
 689                         FSL_CHASSIS2_DCFG_FUSESR_VID_MASK;
 690         }
 691 #else
 692         vid = (fusesr >> FSL_CORENET_DCFG_FUSESR_ALTVID_SHIFT) &
 693                 FSL_CORENET_DCFG_FUSESR_ALTVID_MASK;
 694         if ((vid == 0) || (vid == FSL_CORENET_DCFG_FUSESR_ALTVID_MASK)) {
 695                 vid = (fusesr >> FSL_CORENET_DCFG_FUSESR_VID_SHIFT) &
 696                         FSL_CORENET_DCFG_FUSESR_VID_MASK;
 697         }
 698 #endif
 699         vdd_target = vdd[vid];
 700
 701         /* check override variable for overriding VDD */
 702         vdd_string = env_get(CONFIG_VID_FLS_ENV);
 703         if (vdd_override == 0 && vdd_string &&
 704             !strict_strtoul(vdd_string, 10, &vdd_string_override))
 705                 vdd_override = vdd_string_override;
 706         if (vdd_override >= VDD_MV_MIN && vdd_override <= VDD_MV_MAX) {
 707                 vdd_target = vdd_override * 10; /* convert to 1/10 mV */
 708                 debug("VDD override is %lu\n", vdd_override);
 709         } else if (vdd_override != 0) {
 710                 printf("Invalid value.\n");
 711         }
 712         if (vdd_target == 0) {
 713                 debug("VID: VID not used\n");
 714                 ret = 0;
 715                 goto exit;
 716         } else {
 717                 /* divide and round up by 10 to get a value in mV */
 718                 vdd_target = DIV_ROUND_UP(vdd_target, 10);
 719                 debug("VID: vid = %d mV\n", vdd_target);
 720         }
 721
 722         /*
 723          * Read voltage monitor to check real voltage.
 724          */
 725         vdd_last = read_voltage(i2caddress);
 726         if (vdd_last < 0) {
 727                 printf("VID: Couldn't read sensor abort VID adjustment\n");
 728                 ret = -1;
 729                 goto exit;
 730         }
 731         vdd_current = vdd_last;
 732         debug("VID: Core voltage is currently at %d mV\n", vdd_last);
 733         /*
 734           * Adjust voltage to at or one step above target.
 735           * As measurements are less precise than setting the values
 736           * we may run through dummy steps that cancel each other
 737           * when stepping up and then down.
 738           */
 739         while (vdd_last > 0 &&
 740                vdd_last < vdd_target) {
 741                 vdd_current += IR_VDD_STEP_UP;
 742                 vdd_last = set_voltage(i2caddress, vdd_current);
 743         }
 744         while (vdd_last > 0 &&
 745                vdd_last > vdd_target + (IR_VDD_STEP_DOWN - 1)) {
 746                 vdd_current -= IR_VDD_STEP_DOWN;
 747                 vdd_last = set_voltage(i2caddress, vdd_current);
 748         }
 749
 750         if (vdd_last > 0)
 751                 printf("VID: Core voltage after adjustment is at %d mV\n",
 752                        vdd_last);
 753         else
 754                 ret = -1;
 755 exit:
 756         if (re_enable)
 757                 enable_interrupts();
 758
 759         i2c_multiplexer_select_vid_channel(I2C_MUX_CH_DEFAULT);
 760
 761         return ret;
 762 }
 763 #endif
 764
 765 static int print_vdd(void)
 766 {
 767         int vdd_last, ret, i2caddress;
 768
 769         ret = i2c_multiplexer_select_vid_channel(I2C_MUX_CH_VOL_MONITOR);
 770         if (ret) {
 771                 debug("VID : I2c failed to switch channel\n");
 772                 return -1;
 773         }
 774 #if defined(CONFIG_VOL_MONITOR_IR36021_SET) || \
 775         defined(CONFIG_VOL_MONITOR_IR36021_READ)
 776         ret = find_ir_chip_on_i2c();
 777         if (ret < 0) {
 778                 printf("VID: Could not find voltage regulator on I2C.\n");
 779                 goto exit;
 780         } else {
 781                 i2caddress = ret;
 782                 debug("VID: IR Chip found on I2C address 0x%02x\n", i2caddress);
 783         }
 784 #endif
 785
 786         /*
 787          * Read voltage monitor to check real voltage.
 788          */
 789         vdd_last = read_voltage(i2caddress);
 790         if (vdd_last < 0) {
 791                 printf("VID: Couldn't read sensor abort VID adjustment\n");
 792                 goto exit;
 793         }
 794         printf("VID: Core voltage is at %d mV\n", vdd_last);
 795 exit:
 796         i2c_multiplexer_select_vid_channel(I2C_MUX_CH_DEFAULT);
 797
 798         return ret < 0 ? -1 : 0;
 799
 800 }
 801
 802 static int do_vdd_override(cmd_tbl_t *cmdtp,
 803                            int flag, int argc,
 804                            char * const argv[])
 805 {
 806         ulong override;
 807
 808         if (argc < 2)
 809                 return CMD_RET_USAGE;
 810
 811         if (!strict_strtoul(argv[1], 10, &override))
 812                 adjust_vdd(override);   /* the value is checked by callee */
 813         else
 814                 return CMD_RET_USAGE;
 815         return 0;
 816 }
 817
 818 static int do_vdd_read(cmd_tbl_t *cmdtp,
 819                          int flag, int argc,
 820                          char * const argv[])
 821 {
 822         if (argc < 1)
 823                 return CMD_RET_USAGE;
 824         print_vdd();
 825
 826         return 0;
 827 }
 828
 829 U_BOOT_CMD(
 830         vdd_override, 2, 0, do_vdd_override,
 831         "override VDD",
 832         " - override with the voltage specified in mV, eg. 1050"
 833 );
 834
 835 U_BOOT_CMD(
 836         vdd_read, 1, 0, do_vdd_read,
 837         "read VDD",
 838         " - Read the voltage specified in mV"
 839 )