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 int adjust_vdd(ulong vdd_override) 288 { 289 int re_enable = disable_interrupts(); 290 #if defined(CONFIG_FSL_LSCH2) || defined(CONFIG_FSL_LSCH3) 291 struct ccsr_gur *gur = (void *)(CONFIG_SYS_FSL_GUTS_ADDR); 292 #else 293 ccsr_gur_t __iomem *gur = 294 (void __iomem *)(CONFIG_SYS_MPC85xx_GUTS_ADDR); 295 #endif 296 u32 fusesr; 297 u8 vid, buf; 298 int vdd_target, vdd_current, vdd_last; 299 int ret, i2caddress; 300 unsigned long vdd_string_override; 301 char *vdd_string; 302 static const uint16_t vdd[32] = { 303 0, /* unused */ 304 9875, /* 0.9875V */ 305 9750, 306 9625, 307 9500, 308 9375, 309 9250, 310 9125, 311 9000, 312 8875, 313 8750, 314 8625, 315 8500, 316 8375, 317 8250, 318 8125, 319 10000, /* 1.0000V */ 320 10125, 321 10250, 322 10375, 323 10500, 324 10625, 325 10750, 326 10875, 327 11000, 328 0, /* reserved */ 329 }; 330 struct vdd_drive { 331 u8 vid; 332 unsigned voltage; 333 }; 334 335 ret = i2c_multiplexer_select_vid_channel(I2C_MUX_CH_VOL_MONITOR); 336 if (ret) { 337 debug("VID: I2C failed to switch channel\n"); 338 ret = -1; 339 goto exit; 340 } 341 ret = find_ir_chip_on_i2c(); 342 if (ret < 0) { 343 printf("VID: Could not find voltage regulator on I2C.\n"); 344 ret = -1; 345 goto exit; 346 } else { 347 i2caddress = ret; 348 debug("VID: IR Chip found on I2C address 0x%02x\n", i2caddress); 349 } 350 351 /* check IR chip work on Intel mode*/ 352 ret = i2c_read(i2caddress, 353 IR36021_INTEL_MODE_OOFSET, 354 1, (void *)&buf, 1); 355 if (ret) { 356 printf("VID: failed to read IR chip mode.\n"); 357 ret = -1; 358 goto exit; 359 } 360 if ((buf & IR36021_MODE_MASK) != IR36021_INTEL_MODE) { 361 printf("VID: IR Chip is not used in Intel mode.\n"); 362 ret = -1; 363 goto exit; 364 } 365 366 /* get the voltage ID from fuse status register */ 367 #ifdef CONFIG_FSL_LSCH3 368 fusesr = in_le32(&gur->dcfg_fusesr); 369 #else 370 fusesr = in_be32(&gur->dcfg_fusesr); 371 #endif 372 /* 373 * VID is used according to the table below 374 * --------------------------------------- 375 * | DA_V | 376 * |-------------------------------------| 377 * | 5b00000 | 5b00001-5b11110 | 5b11111 | 378 * ---------------+---------+-----------------+---------| 379 * | D | 5b00000 | NO VID | VID = DA_V | NO VID | 380 * | A |----------+---------+-----------------+---------| 381 * | _ | 5b00001 |VID = | VID = |VID = | 382 * | V | ~ | DA_V_ALT| DA_V_ALT | DA_A_VLT| 383 * | _ | 5b11110 | | | | 384 * | A |----------+---------+-----------------+---------| 385 * | L | 5b11111 | No VID | VID = DA_V | NO VID | 386 * | T | | | | | 387 * ------------------------------------------------------ 388 */ 389 #ifdef CONFIG_FSL_LSCH2 390 vid = (fusesr >> FSL_CHASSIS2_DCFG_FUSESR_ALTVID_SHIFT) & 391 FSL_CHASSIS2_DCFG_FUSESR_ALTVID_MASK; 392 if ((vid == 0) || (vid == FSL_CHASSIS2_DCFG_FUSESR_ALTVID_MASK)) { 393 vid = (fusesr >> FSL_CHASSIS2_DCFG_FUSESR_VID_SHIFT) & 394 FSL_CHASSIS2_DCFG_FUSESR_VID_MASK; 395 } 396 #elif defined(CONFIG_FSL_LSCH3) 397 vid = (fusesr >> FSL_CHASSIS3_DCFG_FUSESR_ALTVID_SHIFT) & 398 FSL_CHASSIS3_DCFG_FUSESR_ALTVID_MASK; 399 if ((vid == 0) || (vid == FSL_CHASSIS3_DCFG_FUSESR_ALTVID_MASK)) { 400 vid = (fusesr >> FSL_CHASSIS3_DCFG_FUSESR_VID_SHIFT) & 401 FSL_CHASSIS3_DCFG_FUSESR_VID_MASK; 402 } 403 #else 404 vid = (fusesr >> FSL_CORENET_DCFG_FUSESR_ALTVID_SHIFT) & 405 FSL_CORENET_DCFG_FUSESR_ALTVID_MASK; 406 if ((vid == 0) || (vid == FSL_CORENET_DCFG_FUSESR_ALTVID_MASK)) { 407 vid = (fusesr >> FSL_CORENET_DCFG_FUSESR_VID_SHIFT) & 408 FSL_CORENET_DCFG_FUSESR_VID_MASK; 409 } 410 #endif 411 vdd_target = vdd[vid]; 412 413 /* check override variable for overriding VDD */ 414 vdd_string = getenv(CONFIG_VID_FLS_ENV); 415 if (vdd_override == 0 && vdd_string && 416 !strict_strtoul(vdd_string, 10, &vdd_string_override)) 417 vdd_override = vdd_string_override; 418 if (vdd_override >= VDD_MV_MIN && vdd_override <= VDD_MV_MAX) { 419 vdd_target = vdd_override * 10; /* convert to 1/10 mV */ 420 debug("VDD override is %lu\n", vdd_override); 421 } else if (vdd_override != 0) { 422 printf("Invalid value.\n"); 423 } 424 if (vdd_target == 0) { 425 debug("VID: VID not used\n"); 426 ret = 0; 427 goto exit; 428 } else { 429 /* divide and round up by 10 to get a value in mV */ 430 vdd_target = DIV_ROUND_UP(vdd_target, 10); 431 debug("VID: vid = %d mV\n", vdd_target); 432 } 433 434 /* 435 * Read voltage monitor to check real voltage. 436 */ 437 vdd_last = read_voltage(i2caddress); 438 if (vdd_last < 0) { 439 printf("VID: Couldn't read sensor abort VID adjustment\n"); 440 ret = -1; 441 goto exit; 442 } 443 vdd_current = vdd_last; 444 debug("VID: Core voltage is currently at %d mV\n", vdd_last); 445 /* 446 * Adjust voltage to at or one step above target. 447 * As measurements are less precise than setting the values 448 * we may run through dummy steps that cancel each other 449 * when stepping up and then down. 450 */ 451 while (vdd_last > 0 && 452 vdd_last < vdd_target) { 453 vdd_current += IR_VDD_STEP_UP; 454 vdd_last = set_voltage(i2caddress, vdd_current); 455 } 456 while (vdd_last > 0 && 457 vdd_last > vdd_target + (IR_VDD_STEP_DOWN - 1)) { 458 vdd_current -= IR_VDD_STEP_DOWN; 459 vdd_last = set_voltage(i2caddress, vdd_current); 460 } 461 462 if (vdd_last > 0) 463 printf("VID: Core voltage after adjustment is at %d mV\n", 464 vdd_last); 465 else 466 ret = -1; 467 exit: 468 if (re_enable) 469 enable_interrupts(); 470 471 i2c_multiplexer_select_vid_channel(I2C_MUX_CH_DEFAULT); 472 473 return ret; 474 } 475 476 static int print_vdd(void) 477 { 478 int vdd_last, ret, i2caddress; 479 480 ret = i2c_multiplexer_select_vid_channel(I2C_MUX_CH_VOL_MONITOR); 481 if (ret) { 482 debug("VID : I2c failed to switch channel\n"); 483 return -1; 484 } 485 ret = find_ir_chip_on_i2c(); 486 if (ret < 0) { 487 printf("VID: Could not find voltage regulator on I2C.\n"); 488 goto exit; 489 } else { 490 i2caddress = ret; 491 debug("VID: IR Chip found on I2C address 0x%02x\n", i2caddress); 492 } 493 494 /* 495 * Read voltage monitor to check real voltage. 496 */ 497 vdd_last = read_voltage(i2caddress); 498 if (vdd_last < 0) { 499 printf("VID: Couldn't read sensor abort VID adjustment\n"); 500 goto exit; 501 } 502 printf("VID: Core voltage is at %d mV\n", vdd_last); 503 exit: 504 i2c_multiplexer_select_vid_channel(I2C_MUX_CH_DEFAULT); 505 506 return ret < 0 ? -1 : 0; 507 508 } 509 510 static int do_vdd_override(cmd_tbl_t *cmdtp, 511 int flag, int argc, 512 char * const argv[]) 513 { 514 ulong override; 515 516 if (argc < 2) 517 return CMD_RET_USAGE; 518 519 if (!strict_strtoul(argv[1], 10, &override)) 520 adjust_vdd(override); /* the value is checked by callee */ 521 else 522 return CMD_RET_USAGE; 523 return 0; 524 } 525 526 static int do_vdd_read(cmd_tbl_t *cmdtp, 527 int flag, int argc, 528 char * const argv[]) 529 { 530 if (argc < 1) 531 return CMD_RET_USAGE; 532 print_vdd(); 533 534 return 0; 535 } 536 537 U_BOOT_CMD( 538 vdd_override, 2, 0, do_vdd_override, 539 "override VDD", 540 " - override with the voltage specified in mV, eg. 1050" 541 ); 542 543 U_BOOT_CMD( 544 vdd_read, 1, 0, do_vdd_read, 545 "read VDD", 546 " - Read the voltage specified in mV" 547 ) 548