Merge git://git.denx.de/u-boot-fsl-qoriq
[platform/kernel/u-boot.git] / 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_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 #ifdef CONFIG_FSL_LSCH3
288 int adjust_vdd(ulong vdd_override)
289 {
290         int re_enable = disable_interrupts();
291         struct ccsr_gur *gur = (void *)(CONFIG_SYS_FSL_GUTS_ADDR);
292         u32 fusesr;
293         u8 vid, buf;
294         int vdd_target, vdd_current, vdd_last;
295         int ret, i2caddress;
296         unsigned long vdd_string_override;
297         char *vdd_string;
298         static const uint16_t vdd[32] = {
299                 10500,
300                 0,      /* reserved */
301                 9750,
302                 0,      /* reserved */
303                 9500,
304                 0,      /* reserved */
305                 0,      /* reserved */
306                 0,      /* reserved */
307                 0,      /* reserved */
308                 0,      /* reserved */
309                 0,      /* reserved */
310                 0,      /* reserved */
311                 0,      /* reserved */
312                 0,      /* reserved */
313                 0,      /* reserved */
314                 0,      /* reserved */
315                 10000,  /* 1.0000V */
316                 0,      /* reserved */
317                 10250,
318                 0,      /* reserved */
319                 10500,
320                 0,      /* reserved */
321                 0,      /* reserved */
322                 0,      /* reserved */
323                 0,      /* reserved */
324                 0,      /* reserved */
325                 0,      /* reserved */
326                 0,      /* reserved */
327                 0,      /* reserved */
328                 0,      /* reserved */
329                 0,      /* reserved */
330                 0,      /* reserved */
331         };
332         struct vdd_drive {
333                 u8 vid;
334                 unsigned voltage;
335         };
336
337         ret = i2c_multiplexer_select_vid_channel(I2C_MUX_CH_VOL_MONITOR);
338         if (ret) {
339                 debug("VID: I2C failed to switch channel\n");
340                 ret = -1;
341                 goto exit;
342         }
343         ret = find_ir_chip_on_i2c();
344         if (ret < 0) {
345                 printf("VID: Could not find voltage regulator on I2C.\n");
346                 ret = -1;
347                 goto exit;
348         } else {
349                 i2caddress = ret;
350                 debug("VID: IR Chip found on I2C address 0x%02x\n", i2caddress);
351         }
352
353         /* check IR chip work on Intel mode*/
354         ret = i2c_read(i2caddress,
355                        IR36021_INTEL_MODE_OOFSET,
356                        1, (void *)&buf, 1);
357         if (ret) {
358                 printf("VID: failed to read IR chip mode.\n");
359                 ret = -1;
360                 goto exit;
361         }
362         if ((buf & IR36021_MODE_MASK) != IR36021_INTEL_MODE) {
363                 printf("VID: IR Chip is not used in Intel mode.\n");
364                 ret = -1;
365                 goto exit;
366         }
367
368         /* get the voltage ID from fuse status register */
369         fusesr = in_le32(&gur->dcfg_fusesr);
370         vid = (fusesr >> FSL_CHASSIS3_DCFG_FUSESR_ALTVID_SHIFT) &
371                 FSL_CHASSIS3_DCFG_FUSESR_ALTVID_MASK;
372         if ((vid == 0) || (vid == FSL_CHASSIS3_DCFG_FUSESR_ALTVID_MASK)) {
373                 vid = (fusesr >> FSL_CHASSIS3_DCFG_FUSESR_VID_SHIFT) &
374                         FSL_CHASSIS3_DCFG_FUSESR_VID_MASK;
375         }
376         vdd_target = vdd[vid];
377
378         /* check override variable for overriding VDD */
379         vdd_string = getenv(CONFIG_VID_FLS_ENV);
380         if (vdd_override == 0 && vdd_string &&
381             !strict_strtoul(vdd_string, 10, &vdd_string_override))
382                 vdd_override = vdd_string_override;
383
384         if (vdd_override >= VDD_MV_MIN && vdd_override <= VDD_MV_MAX) {
385                 vdd_target = vdd_override * 10; /* convert to 1/10 mV */
386                 debug("VDD override is %lu\n", vdd_override);
387         } else if (vdd_override != 0) {
388                 printf("Invalid value.\n");
389         }
390
391         /* divide and round up by 10 to get a value in mV */
392         vdd_target = DIV_ROUND_UP(vdd_target, 10);
393         if (vdd_target == 0) {
394                 debug("VID: VID not used\n");
395                 ret = 0;
396                 goto exit;
397         } else if (vdd_target < VDD_MV_MIN || vdd_target > VDD_MV_MAX) {
398                 /* Check vdd_target is in valid range */
399                 printf("VID: Target VID %d mV is not in range.\n",
400                        vdd_target);
401                 ret = -1;
402                 goto exit;
403         } else {
404                 debug("VID: vid = %d mV\n", vdd_target);
405         }
406
407         /*
408          * Read voltage monitor to check real voltage.
409          */
410         vdd_last = read_voltage(i2caddress);
411         if (vdd_last < 0) {
412                 printf("VID: Couldn't read sensor abort VID adjustment\n");
413                 ret = -1;
414                 goto exit;
415         }
416         vdd_current = vdd_last;
417         debug("VID: Core voltage is currently at %d mV\n", vdd_last);
418         /*
419           * Adjust voltage to at or one step above target.
420           * As measurements are less precise than setting the values
421           * we may run through dummy steps that cancel each other
422           * when stepping up and then down.
423           */
424         while (vdd_last > 0 &&
425                vdd_last < vdd_target) {
426                 vdd_current += IR_VDD_STEP_UP;
427                 vdd_last = set_voltage(i2caddress, vdd_current);
428         }
429         while (vdd_last > 0 &&
430                vdd_last > vdd_target + (IR_VDD_STEP_DOWN - 1)) {
431                 vdd_current -= IR_VDD_STEP_DOWN;
432                 vdd_last = set_voltage(i2caddress, vdd_current);
433         }
434
435         if (vdd_last > 0)
436                 printf("VID: Core voltage after adjustment is at %d mV\n",
437                        vdd_last);
438         else
439                 ret = -1;
440 exit:
441         if (re_enable)
442                 enable_interrupts();
443         i2c_multiplexer_select_vid_channel(I2C_MUX_CH_DEFAULT);
444         return ret;
445 }
446 #else /* !CONFIG_FSL_LSCH3 */
447 int adjust_vdd(ulong vdd_override)
448 {
449         int re_enable = disable_interrupts();
450 #if defined(CONFIG_FSL_LSCH2)
451         struct ccsr_gur *gur = (void *)(CONFIG_SYS_FSL_GUTS_ADDR);
452 #else
453         ccsr_gur_t __iomem *gur =
454                 (void __iomem *)(CONFIG_SYS_MPC85xx_GUTS_ADDR);
455 #endif
456         u32 fusesr;
457         u8 vid, buf;
458         int vdd_target, vdd_current, vdd_last;
459         int ret, i2caddress;
460         unsigned long vdd_string_override;
461         char *vdd_string;
462         static const uint16_t vdd[32] = {
463                 0,      /* unused */
464                 9875,   /* 0.9875V */
465                 9750,
466                 9625,
467                 9500,
468                 9375,
469                 9250,
470                 9125,
471                 9000,
472                 8875,
473                 8750,
474                 8625,
475                 8500,
476                 8375,
477                 8250,
478                 8125,
479                 10000,  /* 1.0000V */
480                 10125,
481                 10250,
482                 10375,
483                 10500,
484                 10625,
485                 10750,
486                 10875,
487                 11000,
488                 0,      /* reserved */
489         };
490         struct vdd_drive {
491                 u8 vid;
492                 unsigned voltage;
493         };
494
495         ret = i2c_multiplexer_select_vid_channel(I2C_MUX_CH_VOL_MONITOR);
496         if (ret) {
497                 debug("VID: I2C failed to switch channel\n");
498                 ret = -1;
499                 goto exit;
500         }
501         ret = find_ir_chip_on_i2c();
502         if (ret < 0) {
503                 printf("VID: Could not find voltage regulator on I2C.\n");
504                 ret = -1;
505                 goto exit;
506         } else {
507                 i2caddress = ret;
508                 debug("VID: IR Chip found on I2C address 0x%02x\n", i2caddress);
509         }
510
511         /* check IR chip work on Intel mode*/
512         ret = i2c_read(i2caddress,
513                        IR36021_INTEL_MODE_OOFSET,
514                        1, (void *)&buf, 1);
515         if (ret) {
516                 printf("VID: failed to read IR chip mode.\n");
517                 ret = -1;
518                 goto exit;
519         }
520         if ((buf & IR36021_MODE_MASK) != IR36021_INTEL_MODE) {
521                 printf("VID: IR Chip is not used in Intel mode.\n");
522                 ret = -1;
523                 goto exit;
524         }
525
526         /* get the voltage ID from fuse status register */
527         fusesr = in_be32(&gur->dcfg_fusesr);
528         /*
529          * VID is used according to the table below
530          *                ---------------------------------------
531          *                |                DA_V                 |
532          *                |-------------------------------------|
533          *                | 5b00000 | 5b00001-5b11110 | 5b11111 |
534          * ---------------+---------+-----------------+---------|
535          * | D | 5b00000  | NO VID  | VID = DA_V      | NO VID  |
536          * | A |----------+---------+-----------------+---------|
537          * | _ | 5b00001  |VID =    | VID =           |VID =    |
538          * | V |   ~      | DA_V_ALT|   DA_V_ALT      | DA_A_VLT|
539          * | _ | 5b11110  |         |                 |         |
540          * | A |----------+---------+-----------------+---------|
541          * | L | 5b11111  | No VID  | VID = DA_V      | NO VID  |
542          * | T |          |         |                 |         |
543          * ------------------------------------------------------
544          */
545 #ifdef CONFIG_FSL_LSCH2
546         vid = (fusesr >> FSL_CHASSIS2_DCFG_FUSESR_ALTVID_SHIFT) &
547                 FSL_CHASSIS2_DCFG_FUSESR_ALTVID_MASK;
548         if ((vid == 0) || (vid == FSL_CHASSIS2_DCFG_FUSESR_ALTVID_MASK)) {
549                 vid = (fusesr >> FSL_CHASSIS2_DCFG_FUSESR_VID_SHIFT) &
550                         FSL_CHASSIS2_DCFG_FUSESR_VID_MASK;
551         }
552 #else
553         vid = (fusesr >> FSL_CORENET_DCFG_FUSESR_ALTVID_SHIFT) &
554                 FSL_CORENET_DCFG_FUSESR_ALTVID_MASK;
555         if ((vid == 0) || (vid == FSL_CORENET_DCFG_FUSESR_ALTVID_MASK)) {
556                 vid = (fusesr >> FSL_CORENET_DCFG_FUSESR_VID_SHIFT) &
557                         FSL_CORENET_DCFG_FUSESR_VID_MASK;
558         }
559 #endif
560         vdd_target = vdd[vid];
561
562         /* check override variable for overriding VDD */
563         vdd_string = getenv(CONFIG_VID_FLS_ENV);
564         if (vdd_override == 0 && vdd_string &&
565             !strict_strtoul(vdd_string, 10, &vdd_string_override))
566                 vdd_override = vdd_string_override;
567         if (vdd_override >= VDD_MV_MIN && vdd_override <= VDD_MV_MAX) {
568                 vdd_target = vdd_override * 10; /* convert to 1/10 mV */
569                 debug("VDD override is %lu\n", vdd_override);
570         } else if (vdd_override != 0) {
571                 printf("Invalid value.\n");
572         }
573         if (vdd_target == 0) {
574                 debug("VID: VID not used\n");
575                 ret = 0;
576                 goto exit;
577         } else {
578                 /* divide and round up by 10 to get a value in mV */
579                 vdd_target = DIV_ROUND_UP(vdd_target, 10);
580                 debug("VID: vid = %d mV\n", vdd_target);
581         }
582
583         /*
584          * Read voltage monitor to check real voltage.
585          */
586         vdd_last = read_voltage(i2caddress);
587         if (vdd_last < 0) {
588                 printf("VID: Couldn't read sensor abort VID adjustment\n");
589                 ret = -1;
590                 goto exit;
591         }
592         vdd_current = vdd_last;
593         debug("VID: Core voltage is currently at %d mV\n", vdd_last);
594         /*
595           * Adjust voltage to at or one step above target.
596           * As measurements are less precise than setting the values
597           * we may run through dummy steps that cancel each other
598           * when stepping up and then down.
599           */
600         while (vdd_last > 0 &&
601                vdd_last < vdd_target) {
602                 vdd_current += IR_VDD_STEP_UP;
603                 vdd_last = set_voltage(i2caddress, vdd_current);
604         }
605         while (vdd_last > 0 &&
606                vdd_last > vdd_target + (IR_VDD_STEP_DOWN - 1)) {
607                 vdd_current -= IR_VDD_STEP_DOWN;
608                 vdd_last = set_voltage(i2caddress, vdd_current);
609         }
610
611         if (vdd_last > 0)
612                 printf("VID: Core voltage after adjustment is at %d mV\n",
613                        vdd_last);
614         else
615                 ret = -1;
616 exit:
617         if (re_enable)
618                 enable_interrupts();
619
620         i2c_multiplexer_select_vid_channel(I2C_MUX_CH_DEFAULT);
621
622         return ret;
623 }
624 #endif
625
626 static int print_vdd(void)
627 {
628         int vdd_last, ret, i2caddress;
629
630         ret = i2c_multiplexer_select_vid_channel(I2C_MUX_CH_VOL_MONITOR);
631         if (ret) {
632                 debug("VID : I2c failed to switch channel\n");
633                 return -1;
634         }
635         ret = find_ir_chip_on_i2c();
636         if (ret < 0) {
637                 printf("VID: Could not find voltage regulator on I2C.\n");
638                 goto exit;
639         } else {
640                 i2caddress = ret;
641                 debug("VID: IR Chip found on I2C address 0x%02x\n", i2caddress);
642         }
643
644         /*
645          * Read voltage monitor to check real voltage.
646          */
647         vdd_last = read_voltage(i2caddress);
648         if (vdd_last < 0) {
649                 printf("VID: Couldn't read sensor abort VID adjustment\n");
650                 goto exit;
651         }
652         printf("VID: Core voltage is at %d mV\n", vdd_last);
653 exit:
654         i2c_multiplexer_select_vid_channel(I2C_MUX_CH_DEFAULT);
655
656         return ret < 0 ? -1 : 0;
657
658 }
659
660 static int do_vdd_override(cmd_tbl_t *cmdtp,
661                            int flag, int argc,
662                            char * const argv[])
663 {
664         ulong override;
665
666         if (argc < 2)
667                 return CMD_RET_USAGE;
668
669         if (!strict_strtoul(argv[1], 10, &override))
670                 adjust_vdd(override);   /* the value is checked by callee */
671         else
672                 return CMD_RET_USAGE;
673         return 0;
674 }
675
676 static int do_vdd_read(cmd_tbl_t *cmdtp,
677                          int flag, int argc,
678                          char * const argv[])
679 {
680         if (argc < 1)
681                 return CMD_RET_USAGE;
682         print_vdd();
683
684         return 0;
685 }
686
687 U_BOOT_CMD(
688         vdd_override, 2, 0, do_vdd_override,
689         "override VDD",
690         " - override with the voltage specified in mV, eg. 1050"
691 );
692
693 U_BOOT_CMD(
694         vdd_read, 1, 0, do_vdd_read,
695         "read VDD",
696         " - Read the voltage specified in mV"
697 )