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