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