1 // SPDX-License-Identifier: GPL-2.0+
3 * Copyright 2014 Freescale Semiconductor, Inc.
4 * Copyright 2020-21 NXP
5 * Copyright 2020 Stephen Carlson <stcarlso@linux.microsoft.com>
15 #ifdef CONFIG_FSL_LSCH2
16 #include <asm/arch/immap_lsch2.h>
17 #elif defined(CONFIG_FSL_LSCH3)
18 #include <asm/arch/immap_lsch3.h>
20 #include <asm/immap_85xx.h>
22 #include <linux/delay.h>
23 #include "i2c_common.h"
26 #ifndef I2C_VOL_MONITOR_BUS
27 #define I2C_VOL_MONITOR_BUS 0
30 /* Voltages are generally handled in mV to keep them as integers */
34 * Select the channel on the I2C mux (on some NXP boards) that contains
35 * the voltage regulator to use for VID. Return 0 for success or nonzero
38 int __weak i2c_multiplexer_select_vid_channel(u8 channel)
44 * Compensate for a board specific voltage drop between regulator and SoC.
45 * Returns the voltage offset in mV.
47 int __weak board_vdd_drop_compensation(void)
53 * Performs any board specific adjustments after the VID voltage has been
54 * set. Return 0 for success or nonzero for failure.
56 int __weak board_adjust_vdd(int vdd)
62 * Processor specific method of converting the fuse value read from VID
63 * registers into the core voltage to supply. Return the voltage in mV.
65 u16 __weak soc_get_fuse_vid(int vid_index)
67 /* Default VDD for Layerscape Chassis 1 devices */
68 static const u16 vdd[32] = {
96 return vdd[vid_index];
99 #ifndef I2C_VOL_MONITOR_ADDR
100 #define I2C_VOL_MONITOR_ADDR 0
103 #if defined(CONFIG_VOL_MONITOR_IR36021_SET) || \
104 defined(CONFIG_VOL_MONITOR_IR36021_READ)
106 * Get the i2c address configuration for the IR regulator chip
108 * There are some variance in the RDB HW regarding the I2C address configuration
109 * for the IR regulator chip, which is likely a problem of external resistor
110 * accuracy. So we just check each address in a hopefully non-intrusive mode
111 * and use the first one that seems to work
113 * The IR chip can show up under the following addresses:
114 * 0x08 (Verified on T1040RDB-PA,T4240RDB-PB,X-T4240RDB-16GPA)
115 * 0x09 (Verified on T1040RDB-PA)
116 * 0x38 (Verified on T2080QDS, T2081QDS, T4240RDB)
118 static int find_ir_chip_on_i2c(void)
120 int i2caddress, ret, i;
122 const int ir_i2c_addr[] = {0x38, 0x08, 0x09};
125 /* Check all the address */
126 for (i = 0; i < (sizeof(ir_i2c_addr)/sizeof(ir_i2c_addr[0])); i++) {
127 i2caddress = ir_i2c_addr[i];
128 ret = fsl_i2c_get_device(i2caddress, I2C_VOL_MONITOR_BUS, &dev);
130 ret = I2C_READ(dev, IR36021_MFR_ID_OFFSET,
131 (void *)&mfrID, sizeof(mfrID));
132 /* If manufacturer ID matches the IR36021 */
133 if (!ret && mfrID == IR36021_MFR_ID)
141 /* Maximum loop count waiting for new voltage to take effect */
142 #define MAX_LOOP_WAIT_NEW_VOL 100
143 /* Maximum loop count waiting for the voltage to be stable */
144 #define MAX_LOOP_WAIT_VOL_STABLE 100
146 * read_voltage from sensor on I2C bus
147 * We use average of 4 readings, waiting for WAIT_FOR_ADC before
150 #define NUM_READINGS 4 /* prefer to be power of 2 for efficiency */
152 /* If an INA220 chip is available, we can use it to read back the voltage
153 * as it may have a higher accuracy than the IR chip for the same purpose
155 #ifdef CONFIG_VOL_MONITOR_INA220
156 #define WAIT_FOR_ADC 532 /* wait for 532 microseconds for ADC */
157 #define ADC_MIN_ACCURACY 4
159 #define WAIT_FOR_ADC 138 /* wait for 138 microseconds for ADC */
160 #define ADC_MIN_ACCURACY 4
163 #ifdef CONFIG_VOL_MONITOR_INA220
164 static int read_voltage_from_INA220(int i2caddress)
166 int i, ret, voltage_read = 0;
171 /* Open device handle */
172 ret = fsl_i2c_get_device(i2caddress, I2C_VOL_MONITOR_BUS, &dev);
176 for (i = 0; i < NUM_READINGS; i++) {
177 ret = I2C_READ(dev, I2C_VOL_MONITOR_BUS_V_OFFSET,
178 (void *)&buf[0], sizeof(buf));
180 printf("VID: failed to read core voltage\n");
184 vol_mon = (buf[0] << 8) | buf[1];
185 if (vol_mon & I2C_VOL_MONITOR_BUS_V_OVF) {
186 printf("VID: Core voltage sensor error\n");
190 debug("VID: bus voltage reads 0x%04x\n", vol_mon);
192 voltage_read += (vol_mon >> I2C_VOL_MONITOR_BUS_V_SHIFT) * 4;
193 udelay(WAIT_FOR_ADC);
196 /* calculate the average */
197 voltage_read /= NUM_READINGS;
203 #ifdef CONFIG_VOL_MONITOR_IR36021_READ
204 /* read voltage from IR */
205 static int read_voltage_from_IR(int i2caddress)
207 int i, ret, voltage_read = 0;
212 /* Open device handle */
213 ret = fsl_i2c_get_device(i2caddress, I2C_VOL_MONITOR_BUS, &dev);
217 for (i = 0; i < NUM_READINGS; i++) {
218 ret = I2C_READ(dev, IR36021_LOOP1_VOUT_OFFSET, (void *)&buf,
221 printf("VID: failed to read core voltage\n");
226 printf("VID: Core voltage sensor error\n");
229 debug("VID: bus voltage reads 0x%02x\n", vol_mon);
230 /* Resolution is 1/128V. We scale up here to get 1/128mV
231 * and divide at the end
233 voltage_read += vol_mon * MV_PER_V;
234 udelay(WAIT_FOR_ADC);
236 /* Scale down to the real mV as IR resolution is 1/128V, rounding up */
237 voltage_read = DIV_ROUND_UP(voltage_read, 128);
239 /* calculate the average */
240 voltage_read /= NUM_READINGS;
242 /* Compensate for a board specific voltage drop between regulator and
243 * SoC before converting into an IR VID value
245 voltage_read -= board_vdd_drop_compensation();
251 #if defined(CONFIG_VOL_MONITOR_ISL68233_READ) || \
252 defined(CONFIG_VOL_MONITOR_LTC3882_READ) || \
253 defined(CONFIG_VOL_MONITOR_ISL68233_SET) || \
254 defined(CONFIG_VOL_MONITOR_LTC3882_SET)
257 * The message displayed if the VOUT exponent causes a resolution
258 * worse than 1.0 V (if exponent is >= 0).
260 #define VOUT_WARNING "VID: VOUT_MODE exponent has resolution worse than 1 V!\n"
262 /* Checks the PMBus voltage monitor for the format used for voltage values */
263 static int get_pmbus_multiplier(DEVICE_HANDLE_T dev)
266 int exponent, multiplier, ret;
268 ret = I2C_READ(dev, PMBUS_CMD_VOUT_MODE, &mode, sizeof(mode));
270 printf("VID: unable to determine voltage multiplier\n");
274 /* Upper 3 bits is mode, lower 5 bits is exponent */
275 exponent = (int)mode & 0x1F;
279 /* Linear, 5 bit twos component exponent */
280 if (exponent & 0x10) {
281 multiplier = 1 << (16 - (exponent & 0xF));
283 /* If exponent is >= 0, then resolution is 1 V! */
284 printf(VOUT_WARNING);
289 /* VID code identifier */
290 printf("VID: custom VID codes are not supported\n");
291 multiplier = MV_PER_V;
295 multiplier = MV_PER_V;
299 debug("VID: calculated multiplier is %d\n", multiplier);
304 #if defined(CONFIG_VOL_MONITOR_ISL68233_READ) || \
305 defined(CONFIG_VOL_MONITOR_LTC3882_READ)
306 static int read_voltage_from_pmbus(int i2caddress)
308 int ret, multiplier, vout;
309 u8 channel = PWM_CHANNEL0;
313 /* Open device handle */
314 ret = fsl_i2c_get_device(i2caddress, I2C_VOL_MONITOR_BUS, &dev);
318 /* Select the right page */
319 ret = I2C_WRITE(dev, PMBUS_CMD_PAGE, &channel, sizeof(channel));
321 printf("VID: failed to select VDD page %d\n", channel);
325 /* VOUT is little endian */
326 ret = I2C_READ(dev, PMBUS_CMD_READ_VOUT, (void *)&vcode, sizeof(vcode));
328 printf("VID: failed to read core voltage\n");
332 /* Scale down to the real mV */
333 multiplier = get_pmbus_multiplier(dev);
335 /* Multiplier 1000 (direct mode) requires no change to convert */
336 if (multiplier != MV_PER_V)
337 vout = DIV_ROUND_UP(vout * MV_PER_V, multiplier);
338 return vout - board_vdd_drop_compensation();
342 static int read_voltage(int i2caddress)
345 #ifdef CONFIG_VOL_MONITOR_INA220
346 voltage_read = read_voltage_from_INA220(I2C_VOL_MONITOR_ADDR);
347 #elif defined CONFIG_VOL_MONITOR_IR36021_READ
348 voltage_read = read_voltage_from_IR(i2caddress);
349 #elif defined(CONFIG_VOL_MONITOR_ISL68233_READ) || \
350 defined(CONFIG_VOL_MONITOR_LTC3882_READ)
351 voltage_read = read_voltage_from_pmbus(i2caddress);
358 #ifdef CONFIG_VOL_MONITOR_IR36021_SET
360 * We need to calculate how long before the voltage stops to drop
361 * or increase. It returns with the loop count. Each loop takes
362 * several readings (WAIT_FOR_ADC)
364 static int wait_for_new_voltage(int vdd, int i2caddress)
366 int timeout, vdd_current;
368 vdd_current = read_voltage(i2caddress);
369 /* wait until voltage starts to reach the target. Voltage slew
370 * rates by typical regulators will always lead to stable readings
371 * within each fairly long ADC interval in comparison to the
372 * intended voltage delta change until the target voltage is
373 * reached. The fairly small voltage delta change to any target
374 * VID voltage also means that this function will always complete
375 * within few iterations. If the timeout was ever reached, it would
376 * point to a serious failure in the regulator system.
379 abs(vdd - vdd_current) > (IR_VDD_STEP_UP + IR_VDD_STEP_DOWN) &&
380 timeout < MAX_LOOP_WAIT_NEW_VOL; timeout++) {
381 vdd_current = read_voltage(i2caddress);
383 if (timeout >= MAX_LOOP_WAIT_NEW_VOL) {
384 printf("VID: Voltage adjustment timeout\n");
391 * Blocks and reads the VID voltage until it stabilizes, or the
394 static int wait_for_voltage_stable(int i2caddress)
396 int timeout, vdd_current, vdd;
398 vdd = read_voltage(i2caddress);
399 udelay(NUM_READINGS * WAIT_FOR_ADC);
401 vdd_current = read_voltage(i2caddress);
403 * The maximum timeout is
404 * MAX_LOOP_WAIT_VOL_STABLE * NUM_READINGS * WAIT_FOR_ADC
406 for (timeout = MAX_LOOP_WAIT_VOL_STABLE;
407 abs(vdd - vdd_current) > ADC_MIN_ACCURACY &&
408 timeout > 0; timeout--) {
410 udelay(NUM_READINGS * WAIT_FOR_ADC);
411 vdd_current = read_voltage(i2caddress);
418 /* Sets the VID voltage using the IR36021 */
419 static int set_voltage_to_IR(int i2caddress, int vdd)
426 /* Open device handle */
427 ret = fsl_i2c_get_device(i2caddress, I2C_VOL_MONITOR_BUS, &dev);
431 /* Compensate for a board specific voltage drop between regulator and
432 * SoC before converting into an IR VID value
434 vdd += board_vdd_drop_compensation();
435 #ifdef CONFIG_FSL_LSCH2
436 vid = DIV_ROUND_UP(vdd - 265, 5);
438 vid = DIV_ROUND_UP(vdd - 245, 5);
441 ret = I2C_WRITE(dev, IR36021_LOOP1_MANUAL_ID_OFFSET, (void *)&vid,
444 printf("VID: failed to write new voltage\n");
447 wait = wait_for_new_voltage(vdd, i2caddress);
450 debug("VID: Waited %d us\n", wait * NUM_READINGS * WAIT_FOR_ADC);
452 vdd_last = wait_for_voltage_stable(i2caddress);
455 debug("VID: Current voltage is %d mV\n", vdd_last);
460 #if defined(CONFIG_VOL_MONITOR_ISL68233_SET) || \
461 defined(CONFIG_VOL_MONITOR_LTC3882_SET)
462 static int set_voltage_to_pmbus(int i2caddress, int vdd)
464 int ret, vdd_last, vdd_target = vdd;
465 int count = MAX_LOOP_WAIT_NEW_VOL, temp = 0, multiplier;
468 /* The data to be sent with the PMBus command PAGE_PLUS_WRITE */
469 u8 buffer[5] = { 0x04, PWM_CHANNEL0, PMBUS_CMD_VOUT_COMMAND, 0, 0 };
472 /* Open device handle */
473 ret = fsl_i2c_get_device(i2caddress, I2C_VOL_MONITOR_BUS, &dev);
477 /* Scale up to the proper value for the VOUT command, little endian */
478 multiplier = get_pmbus_multiplier(dev);
479 vdd += board_vdd_drop_compensation();
480 if (multiplier != MV_PER_V)
481 vdd = DIV_ROUND_UP(vdd * multiplier, MV_PER_V);
482 buffer[3] = vdd & 0xFF;
483 buffer[4] = (vdd & 0xFF00) >> 8;
485 /* Check write protect state */
486 ret = I2C_READ(dev, PMBUS_CMD_WRITE_PROTECT, (void *)&value,
491 if (value != EN_WRITE_ALL_CMD) {
492 value = EN_WRITE_ALL_CMD;
493 ret = I2C_WRITE(dev, PMBUS_CMD_WRITE_PROTECT,
494 (void *)&value, sizeof(value));
499 /* Write the desired voltage code to the regulator */
500 ret = I2C_WRITE(dev, PMBUS_CMD_PAGE_PLUS_WRITE, (void *)&buffer[0],
503 printf("VID: I2C failed to write to the voltage regulator\n");
508 /* Wait for the voltage to get to the desired value */
510 vdd_last = read_voltage_from_pmbus(i2caddress);
512 printf("VID: Couldn't read sensor abort VID adjust\n");
516 temp = vdd_last - vdd_target;
517 } while ((abs(temp) > 2) && (count > 0));
523 static int set_voltage(int i2caddress, int vdd)
527 #ifdef CONFIG_VOL_MONITOR_IR36021_SET
528 vdd_last = set_voltage_to_IR(i2caddress, vdd);
529 #elif defined(CONFIG_VOL_MONITOR_ISL68233_SET) || \
530 defined(CONFIG_VOL_MONITOR_LTC3882_SET)
531 vdd_last = set_voltage_to_pmbus(i2caddress, vdd);
533 #error Specific voltage monitor must be defined
538 int adjust_vdd(ulong vdd_override)
540 int re_enable = disable_interrupts();
541 #if defined(CONFIG_FSL_LSCH2) || defined(CONFIG_FSL_LSCH3)
542 struct ccsr_gur *gur = (void *)(CFG_SYS_FSL_GUTS_ADDR);
544 ccsr_gur_t __iomem *gur =
545 (void __iomem *)(CFG_SYS_MPC85xx_GUTS_ADDR);
549 int vdd_current, vdd_last, vdd_target;
550 int ret, i2caddress = I2C_VOL_MONITOR_ADDR;
551 unsigned long vdd_string_override;
554 #if defined(CONFIG_VOL_MONITOR_IR36021_SET) || \
555 defined(CONFIG_VOL_MONITOR_IR36021_READ)
561 * VID is used according to the table below
562 * ---------------------------------------
564 * |-------------------------------------|
565 * | 5b00000 | 5b00001-5b11110 | 5b11111 |
566 * ---------------+---------+-----------------+---------|
567 * | D | 5b00000 | NO VID | VID = DA_V | NO VID |
568 * | A |----------+---------+-----------------+---------|
569 * | _ | 5b00001 |VID = | VID = |VID = |
570 * | V | ~ | DA_V_ALT| DA_V_ALT | DA_A_VLT|
571 * | _ | 5b11110 | | | |
572 * | A |----------+---------+-----------------+---------|
573 * | L | 5b11111 | No VID | VID = DA_V | NO VID |
575 * ------------------------------------------------------
577 #if defined(CONFIG_FSL_LSCH3)
578 fusesr = in_le32(&gur->dcfg_fusesr);
579 vid = (fusesr >> FSL_CHASSIS3_DCFG_FUSESR_ALTVID_SHIFT) &
580 FSL_CHASSIS3_DCFG_FUSESR_ALTVID_MASK;
581 if (vid == 0 || vid == FSL_CHASSIS3_DCFG_FUSESR_ALTVID_MASK) {
582 vid = (fusesr >> FSL_CHASSIS3_DCFG_FUSESR_VID_SHIFT) &
583 FSL_CHASSIS3_DCFG_FUSESR_VID_MASK;
585 #elif defined(CONFIG_FSL_LSCH2)
586 fusesr = in_be32(&gur->dcfg_fusesr);
587 vid = (fusesr >> FSL_CHASSIS2_DCFG_FUSESR_ALTVID_SHIFT) &
588 FSL_CHASSIS2_DCFG_FUSESR_ALTVID_MASK;
589 if (vid == 0 || vid == FSL_CHASSIS2_DCFG_FUSESR_ALTVID_MASK) {
590 vid = (fusesr >> FSL_CHASSIS2_DCFG_FUSESR_VID_SHIFT) &
591 FSL_CHASSIS2_DCFG_FUSESR_VID_MASK;
594 fusesr = in_be32(&gur->dcfg_fusesr);
595 vid = (fusesr >> FSL_CORENET_DCFG_FUSESR_ALTVID_SHIFT) &
596 FSL_CORENET_DCFG_FUSESR_ALTVID_MASK;
597 if (vid == 0 || vid == FSL_CORENET_DCFG_FUSESR_ALTVID_MASK) {
598 vid = (fusesr >> FSL_CORENET_DCFG_FUSESR_VID_SHIFT) &
599 FSL_CORENET_DCFG_FUSESR_VID_MASK;
602 vdd_target = soc_get_fuse_vid((int)vid);
604 ret = i2c_multiplexer_select_vid_channel(I2C_MUX_CH_VOL_MONITOR);
606 debug("VID: I2C failed to switch channel\n");
611 #if defined(CONFIG_VOL_MONITOR_IR36021_SET) || \
612 defined(CONFIG_VOL_MONITOR_IR36021_READ)
613 ret = find_ir_chip_on_i2c();
615 printf("VID: Could not find voltage regulator on I2C.\n");
620 debug("VID: IR Chip found on I2C address 0x%02x\n", i2caddress);
623 ret = fsl_i2c_get_device(i2caddress, I2C_VOL_MONITOR_BUS, &dev);
627 /* check IR chip work on Intel mode */
628 ret = I2C_READ(dev, IR36021_INTEL_MODE_OFFSET, (void *)&buf,
631 printf("VID: failed to read IR chip mode.\n");
635 if ((buf & IR36021_MODE_MASK) != IR36021_INTEL_MODE) {
636 printf("VID: IR Chip is not used in Intel mode.\n");
642 /* check override variable for overriding VDD */
643 vdd_string = env_get(CONFIG_VID_FLS_ENV);
644 debug("VID: Initial VDD value is %d mV\n",
645 DIV_ROUND_UP(vdd_target, 10));
646 if (vdd_override == 0 && vdd_string &&
647 !strict_strtoul(vdd_string, 10, &vdd_string_override))
648 vdd_override = vdd_string_override;
649 if (vdd_override >= VDD_MV_MIN && vdd_override <= VDD_MV_MAX) {
650 vdd_target = vdd_override * 10; /* convert to 1/10 mV */
651 debug("VID: VDD override is %lu\n", vdd_override);
652 } else if (vdd_override != 0) {
653 printf("VID: Invalid VDD value.\n");
655 if (vdd_target == 0) {
656 debug("VID: VID not used\n");
660 /* divide and round up by 10 to get a value in mV */
661 vdd_target = DIV_ROUND_UP(vdd_target, 10);
662 debug("VID: vid = %d mV\n", vdd_target);
666 * Read voltage monitor to check real voltage.
668 vdd_last = read_voltage(i2caddress);
670 printf("VID: Couldn't read sensor abort VID adjustment\n");
674 vdd_current = vdd_last;
675 debug("VID: Core voltage is currently at %d mV\n", vdd_last);
677 #if defined(CONFIG_VOL_MONITOR_LTC3882_SET) || \
678 defined(CONFIG_VOL_MONITOR_ISL68233_SET)
679 /* Set the target voltage */
680 vdd_current = set_voltage(i2caddress, vdd_target);
681 vdd_last = vdd_current;
684 * Adjust voltage to at or one step above target.
685 * As measurements are less precise than setting the values
686 * we may run through dummy steps that cancel each other
687 * when stepping up and then down.
689 while (vdd_last > 0 &&
690 vdd_last < vdd_target) {
691 vdd_current += IR_VDD_STEP_UP;
692 vdd_last = set_voltage(i2caddress, vdd_current);
694 while (vdd_last > 0 &&
695 vdd_last > vdd_target + (IR_VDD_STEP_DOWN - 1)) {
696 vdd_current -= IR_VDD_STEP_DOWN;
697 vdd_last = set_voltage(i2caddress, vdd_current);
701 /* Board specific adjustments */
702 if (board_adjust_vdd(vdd_target) < 0) {
708 printf("VID: Core voltage after adjustment is at %d mV\n",
716 i2c_multiplexer_select_vid_channel(I2C_MUX_CH_DEFAULT);
721 static int print_vdd(void)
723 int vdd_last, ret, i2caddress = I2C_VOL_MONITOR_ADDR;
725 ret = i2c_multiplexer_select_vid_channel(I2C_MUX_CH_VOL_MONITOR);
727 debug("VID : I2c failed to switch channel\n");
730 #if defined(CONFIG_VOL_MONITOR_IR36021_SET) || \
731 defined(CONFIG_VOL_MONITOR_IR36021_READ)
732 ret = find_ir_chip_on_i2c();
734 printf("VID: Could not find voltage regulator on I2C.\n");
738 debug("VID: IR Chip found on I2C address 0x%02x\n", i2caddress);
743 * Read voltage monitor to check real voltage.
745 vdd_last = read_voltage(i2caddress);
747 printf("VID: Couldn't read sensor abort VID adjustment\n");
750 printf("VID: Core voltage is at %d mV\n", vdd_last);
752 i2c_multiplexer_select_vid_channel(I2C_MUX_CH_DEFAULT);
754 return ret < 0 ? -1 : 0;
757 static int do_vdd_override(struct cmd_tbl *cmdtp,
765 return CMD_RET_USAGE;
767 if (!strict_strtoul(argv[1], 10, &override)) {
768 ret = adjust_vdd(override);
770 return CMD_RET_FAILURE;
772 return CMD_RET_USAGE;
776 static int do_vdd_read(struct cmd_tbl *cmdtp, int flag, int argc,
780 return CMD_RET_USAGE;
787 vdd_override, 2, 0, do_vdd_override,
789 " - override with the voltage specified in mV, eg. 1050"
793 vdd_read, 1, 0, do_vdd_read,
795 " - Read the voltage specified in mV"