1
2
3
4
5
6
7
8#include <common.h>
9#include <command.h>
10#include <env.h>
11#include <i2c.h>
12#include <irq_func.h>
13#include <log.h>
14#include <asm/io.h>
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>
19#else
20#include <asm/immap_85xx.h>
21#endif
22#include <linux/delay.h>
23#include "i2c_common.h"
24#include "vid.h"
25
26#ifndef I2C_VOL_MONITOR_BUS
27#define I2C_VOL_MONITOR_BUS 0
28#endif
29
30
31#define MV_PER_V 1000
32
33
34
35
36
37
38int __weak i2c_multiplexer_select_vid_channel(u8 channel)
39{
40 return 0;
41}
42
43
44
45
46
47int __weak board_vdd_drop_compensation(void)
48{
49 return 0;
50}
51
52
53
54
55
56int __weak board_adjust_vdd(int vdd)
57{
58 return 0;
59}
60
61
62
63
64
65u16 __weak soc_get_fuse_vid(int vid_index)
66{
67
68 static const u16 vdd[32] = {
69 0,
70 9875,
71 9750,
72 9625,
73 9500,
74 9375,
75 9250,
76 9125,
77 9000,
78 8875,
79 8750,
80 8625,
81 8500,
82 8375,
83 8250,
84 8125,
85 10000,
86 10125,
87 10250,
88 10375,
89 10500,
90 10625,
91 10750,
92 10875,
93 11000,
94 0,
95 };
96 return vdd[vid_index];
97}
98
99#ifndef I2C_VOL_MONITOR_ADDR
100#define I2C_VOL_MONITOR_ADDR 0
101#endif
102
103#if defined(CONFIG_VOL_MONITOR_IR36021_SET) || \
104 defined(CONFIG_VOL_MONITOR_IR36021_READ)
105
106
107
108
109
110
111
112
113
114
115
116
117
118static int find_ir_chip_on_i2c(void)
119{
120 int i2caddress, ret, i;
121 u8 mfrID;
122 const int ir_i2c_addr[] = {0x38, 0x08, 0x09};
123 DEVICE_HANDLE_T dev;
124
125
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);
129 if (!ret) {
130 ret = I2C_READ(dev, IR36021_MFR_ID_OFFSET,
131 (void *)&mfrID, sizeof(mfrID));
132
133 if (!ret && mfrID == IR36021_MFR_ID)
134 return i2caddress;
135 }
136 }
137 return -1;
138}
139#endif
140
141
142#define MAX_LOOP_WAIT_NEW_VOL 100
143
144#define MAX_LOOP_WAIT_VOL_STABLE 100
145
146
147
148
149
150#define NUM_READINGS 4
151
152
153
154
155#ifdef CONFIG_VOL_MONITOR_INA220
156#define WAIT_FOR_ADC 532
157#define ADC_MIN_ACCURACY 4
158#else
159#define WAIT_FOR_ADC 138
160#define ADC_MIN_ACCURACY 4
161#endif
162
163#ifdef CONFIG_VOL_MONITOR_INA220
164static int read_voltage_from_INA220(int i2caddress)
165{
166 int i, ret, voltage_read = 0;
167 u16 vol_mon;
168 u8 buf[2];
169 DEVICE_HANDLE_T dev;
170
171
172 ret = fsl_i2c_get_device(i2caddress, I2C_VOL_MONITOR_BUS, &dev);
173 if (ret)
174 return ret;
175
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));
179 if (ret) {
180 printf("VID: failed to read core voltage\n");
181 return ret;
182 }
183
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");
187 return -1;
188 }
189
190 debug("VID: bus voltage reads 0x%04x\n", vol_mon);
191
192 voltage_read += (vol_mon >> I2C_VOL_MONITOR_BUS_V_SHIFT) * 4;
193 udelay(WAIT_FOR_ADC);
194 }
195
196
197 voltage_read /= NUM_READINGS;
198
199 return voltage_read;
200}
201#endif
202
203#ifdef CONFIG_VOL_MONITOR_IR36021_READ
204
205static int read_voltage_from_IR(int i2caddress)
206{
207 int i, ret, voltage_read = 0;
208 u16 vol_mon;
209 u8 buf;
210 DEVICE_HANDLE_T dev;
211
212
213 ret = fsl_i2c_get_device(i2caddress, I2C_VOL_MONITOR_BUS, &dev);
214 if (ret)
215 return ret;
216
217 for (i = 0; i < NUM_READINGS; i++) {
218 ret = I2C_READ(dev, IR36021_LOOP1_VOUT_OFFSET, (void *)&buf,
219 sizeof(buf));
220 if (ret) {
221 printf("VID: failed to read core voltage\n");
222 return ret;
223 }
224 vol_mon = buf;
225 if (!vol_mon) {
226 printf("VID: Core voltage sensor error\n");
227 return -1;
228 }
229 debug("VID: bus voltage reads 0x%02x\n", vol_mon);
230
231
232
233 voltage_read += vol_mon * MV_PER_V;
234 udelay(WAIT_FOR_ADC);
235 }
236
237 voltage_read = DIV_ROUND_UP(voltage_read, 128);
238
239
240 voltage_read /= NUM_READINGS;
241
242
243
244
245 voltage_read -= board_vdd_drop_compensation();
246
247 return voltage_read;
248}
249#endif
250
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)
255
256
257
258
259
260#define VOUT_WARNING "VID: VOUT_MODE exponent has resolution worse than 1 V!\n"
261
262
263static int get_pmbus_multiplier(DEVICE_HANDLE_T dev)
264{
265 u8 mode;
266 int exponent, multiplier, ret;
267
268 ret = I2C_READ(dev, PMBUS_CMD_VOUT_MODE, &mode, sizeof(mode));
269 if (ret) {
270 printf("VID: unable to determine voltage multiplier\n");
271 return 1;
272 }
273
274
275 exponent = (int)mode & 0x1F;
276 mode >>= 5;
277 switch (mode) {
278 case 0:
279
280 if (exponent & 0x10) {
281 multiplier = 1 << (16 - (exponent & 0xF));
282 } else {
283
284 printf(VOUT_WARNING);
285 multiplier = 1;
286 }
287 break;
288 case 1:
289
290 printf("VID: custom VID codes are not supported\n");
291 multiplier = MV_PER_V;
292 break;
293 default:
294
295 multiplier = MV_PER_V;
296 break;
297 }
298
299 debug("VID: calculated multiplier is %d\n", multiplier);
300 return multiplier;
301}
302#endif
303
304#if defined(CONFIG_VOL_MONITOR_ISL68233_READ) || \
305 defined(CONFIG_VOL_MONITOR_LTC3882_READ)
306static int read_voltage_from_pmbus(int i2caddress)
307{
308 int ret, multiplier, vout;
309 u8 channel = PWM_CHANNEL0;
310 u16 vcode;
311 DEVICE_HANDLE_T dev;
312
313
314 ret = fsl_i2c_get_device(i2caddress, I2C_VOL_MONITOR_BUS, &dev);
315 if (ret)
316 return ret;
317
318
319 ret = I2C_WRITE(dev, PMBUS_CMD_PAGE, &channel, sizeof(channel));
320 if (ret) {
321 printf("VID: failed to select VDD page %d\n", channel);
322 return ret;
323 }
324
325
326 ret = I2C_READ(dev, PMBUS_CMD_READ_VOUT, (void *)&vcode, sizeof(vcode));
327 if (ret) {
328 printf("VID: failed to read core voltage\n");
329 return ret;
330 }
331
332
333 multiplier = get_pmbus_multiplier(dev);
334 vout = (int)vcode;
335
336 if (multiplier != MV_PER_V)
337 vout = DIV_ROUND_UP(vout * MV_PER_V, multiplier);
338 return vout - board_vdd_drop_compensation();
339}
340#endif
341
342static int read_voltage(int i2caddress)
343{
344 int voltage_read;
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);
352#else
353 voltage_read = -1;
354#endif
355 return voltage_read;
356}
357
358#ifdef CONFIG_VOL_MONITOR_IR36021_SET
359
360
361
362
363
364static int wait_for_new_voltage(int vdd, int i2caddress)
365{
366 int timeout, vdd_current;
367
368 vdd_current = read_voltage(i2caddress);
369
370
371
372
373
374
375
376
377
378 for (timeout = 0;
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);
382 }
383 if (timeout >= MAX_LOOP_WAIT_NEW_VOL) {
384 printf("VID: Voltage adjustment timeout\n");
385 return -1;
386 }
387 return timeout;
388}
389
390
391
392
393
394static int wait_for_voltage_stable(int i2caddress)
395{
396 int timeout, vdd_current, vdd;
397
398 vdd = read_voltage(i2caddress);
399 udelay(NUM_READINGS * WAIT_FOR_ADC);
400
401 vdd_current = read_voltage(i2caddress);
402
403
404
405
406 for (timeout = MAX_LOOP_WAIT_VOL_STABLE;
407 abs(vdd - vdd_current) > ADC_MIN_ACCURACY &&
408 timeout > 0; timeout--) {
409 vdd = vdd_current;
410 udelay(NUM_READINGS * WAIT_FOR_ADC);
411 vdd_current = read_voltage(i2caddress);
412 }
413 if (timeout == 0)
414 return -1;
415 return vdd_current;
416}
417
418
419static int set_voltage_to_IR(int i2caddress, int vdd)
420{
421 int wait, vdd_last;
422 int ret;
423 u8 vid;
424 DEVICE_HANDLE_T dev;
425
426
427 ret = fsl_i2c_get_device(i2caddress, I2C_VOL_MONITOR_BUS, &dev);
428 if (ret)
429 return ret;
430
431
432
433
434 vdd += board_vdd_drop_compensation();
435#ifdef CONFIG_FSL_LSCH2
436 vid = DIV_ROUND_UP(vdd - 265, 5);
437#else
438 vid = DIV_ROUND_UP(vdd - 245, 5);
439#endif
440
441 ret = I2C_WRITE(dev, IR36021_LOOP1_MANUAL_ID_OFFSET, (void *)&vid,
442 sizeof(vid));
443 if (ret) {
444 printf("VID: failed to write new voltage\n");
445 return -1;
446 }
447 wait = wait_for_new_voltage(vdd, i2caddress);
448 if (wait < 0)
449 return -1;
450 debug("VID: Waited %d us\n", wait * NUM_READINGS * WAIT_FOR_ADC);
451
452 vdd_last = wait_for_voltage_stable(i2caddress);
453 if (vdd_last < 0)
454 return -1;
455 debug("VID: Current voltage is %d mV\n", vdd_last);
456 return vdd_last;
457}
458#endif
459
460#if defined(CONFIG_VOL_MONITOR_ISL68233_SET) || \
461 defined(CONFIG_VOL_MONITOR_LTC3882_SET)
462static int set_voltage_to_pmbus(int i2caddress, int vdd)
463{
464 int ret, vdd_last, vdd_target = vdd;
465 int count = MAX_LOOP_WAIT_NEW_VOL, temp = 0, multiplier;
466 unsigned char value;
467
468
469 u8 buffer[5] = { 0x04, PWM_CHANNEL0, PMBUS_CMD_VOUT_COMMAND, 0, 0 };
470 DEVICE_HANDLE_T dev;
471
472
473 ret = fsl_i2c_get_device(i2caddress, I2C_VOL_MONITOR_BUS, &dev);
474 if (ret)
475 return ret;
476
477
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;
484
485
486 ret = I2C_READ(dev, PMBUS_CMD_WRITE_PROTECT, (void *)&value,
487 sizeof(value));
488 if (ret)
489 goto exit;
490
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));
495 if (ret)
496 goto exit;
497 }
498
499
500 ret = I2C_WRITE(dev, PMBUS_CMD_PAGE_PLUS_WRITE, (void *)&buffer[0],
501 sizeof(buffer));
502 if (ret) {
503 printf("VID: I2C failed to write to the voltage regulator\n");
504 return -1;
505 }
506
507exit:
508
509 do {
510 vdd_last = read_voltage_from_pmbus(i2caddress);
511 if (vdd_last < 0) {
512 printf("VID: Couldn't read sensor abort VID adjust\n");
513 return -1;
514 }
515 count--;
516 temp = vdd_last - vdd_target;
517 } while ((abs(temp) > 2) && (count > 0));
518
519 return vdd_last;
520}
521#endif
522
523static int set_voltage(int i2caddress, int vdd)
524{
525 int vdd_last = -1;
526
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);
532#else
533 #error Specific voltage monitor must be defined
534#endif
535 return vdd_last;
536}
537
538int adjust_vdd(ulong vdd_override)
539{
540 int re_enable = disable_interrupts();
541#if defined(CONFIG_FSL_LSCH2) || defined(CONFIG_FSL_LSCH3)
542 struct ccsr_gur *gur = (void *)(CONFIG_SYS_FSL_GUTS_ADDR);
543#else
544 ccsr_gur_t __iomem *gur =
545 (void __iomem *)(CONFIG_SYS_MPC85xx_GUTS_ADDR);
546#endif
547 u8 vid;
548 u32 fusesr;
549 int vdd_current, vdd_last, vdd_target;
550 int ret, i2caddress = I2C_VOL_MONITOR_ADDR;
551 unsigned long vdd_string_override;
552 char *vdd_string;
553
554#if defined(CONFIG_VOL_MONITOR_IR36021_SET) || \
555 defined(CONFIG_VOL_MONITOR_IR36021_READ)
556 u8 buf;
557 DEVICE_HANDLE_T dev;
558#endif
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
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;
584 }
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;
592 }
593#else
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;
600 }
601#endif
602 vdd_target = soc_get_fuse_vid((int)vid);
603
604 ret = i2c_multiplexer_select_vid_channel(I2C_MUX_CH_VOL_MONITOR);
605 if (ret) {
606 debug("VID: I2C failed to switch channel\n");
607 ret = -1;
608 goto exit;
609 }
610
611#if defined(CONFIG_VOL_MONITOR_IR36021_SET) || \
612 defined(CONFIG_VOL_MONITOR_IR36021_READ)
613 ret = find_ir_chip_on_i2c();
614 if (ret < 0) {
615 printf("VID: Could not find voltage regulator on I2C.\n");
616 ret = -1;
617 goto exit;
618 } else {
619 i2caddress = ret;
620 debug("VID: IR Chip found on I2C address 0x%02x\n", i2caddress);
621 }
622
623 ret = fsl_i2c_get_device(i2caddress, I2C_VOL_MONITOR_BUS, &dev);
624 if (ret)
625 return ret;
626
627
628 ret = I2C_READ(dev, IR36021_INTEL_MODE_OFFSET, (void *)&buf,
629 sizeof(buf));
630 if (ret) {
631 printf("VID: failed to read IR chip mode.\n");
632 ret = -1;
633 goto exit;
634 }
635 if ((buf & IR36021_MODE_MASK) != IR36021_INTEL_MODE) {
636 printf("VID: IR Chip is not used in Intel mode.\n");
637 ret = -1;
638 goto exit;
639 }
640#endif
641
642
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;
651 debug("VID: VDD override is %lu\n", vdd_override);
652 } else if (vdd_override != 0) {
653 printf("VID: Invalid VDD value.\n");
654 }
655 if (vdd_target == 0) {
656 debug("VID: VID not used\n");
657 ret = 0;
658 goto exit;
659 } else {
660
661 vdd_target = DIV_ROUND_UP(vdd_target, 10);
662 debug("VID: vid = %d mV\n", vdd_target);
663 }
664
665
666
667
668 vdd_last = read_voltage(i2caddress);
669 if (vdd_last < 0) {
670 printf("VID: Couldn't read sensor abort VID adjustment\n");
671 ret = -1;
672 goto exit;
673 }
674 vdd_current = vdd_last;
675 debug("VID: Core voltage is currently at %d mV\n", vdd_last);
676
677#if defined(CONFIG_VOL_MONITOR_LTC3882_SET) || \
678 defined(CONFIG_VOL_MONITOR_ISL68233_SET)
679
680 vdd_current = set_voltage(i2caddress, vdd_target);
681 vdd_last = vdd_current;
682#else
683
684
685
686
687
688
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);
693 }
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);
698 }
699#endif
700
701
702 if (board_adjust_vdd(vdd_target) < 0) {
703 ret = -1;
704 goto exit;
705 }
706
707 if (vdd_last > 0)
708 printf("VID: Core voltage after adjustment is at %d mV\n",
709 vdd_last);
710 else
711 ret = -1;
712exit:
713 if (re_enable)
714 enable_interrupts();
715
716 i2c_multiplexer_select_vid_channel(I2C_MUX_CH_DEFAULT);
717
718 return ret;
719}
720
721static int print_vdd(void)
722{
723 int vdd_last, ret, i2caddress = I2C_VOL_MONITOR_ADDR;
724
725 ret = i2c_multiplexer_select_vid_channel(I2C_MUX_CH_VOL_MONITOR);
726 if (ret) {
727 debug("VID : I2c failed to switch channel\n");
728 return -1;
729 }
730#if defined(CONFIG_VOL_MONITOR_IR36021_SET) || \
731 defined(CONFIG_VOL_MONITOR_IR36021_READ)
732 ret = find_ir_chip_on_i2c();
733 if (ret < 0) {
734 printf("VID: Could not find voltage regulator on I2C.\n");
735 goto exit;
736 } else {
737 i2caddress = ret;
738 debug("VID: IR Chip found on I2C address 0x%02x\n", i2caddress);
739 }
740#endif
741
742
743
744
745 vdd_last = read_voltage(i2caddress);
746 if (vdd_last < 0) {
747 printf("VID: Couldn't read sensor abort VID adjustment\n");
748 goto exit;
749 }
750 printf("VID: Core voltage is at %d mV\n", vdd_last);
751exit:
752 i2c_multiplexer_select_vid_channel(I2C_MUX_CH_DEFAULT);
753
754 return ret < 0 ? -1 : 0;
755}
756
757static int do_vdd_override(struct cmd_tbl *cmdtp,
758 int flag, int argc,
759 char *const argv[])
760{
761 ulong override;
762 int ret = 0;
763
764 if (argc < 2)
765 return CMD_RET_USAGE;
766
767 if (!strict_strtoul(argv[1], 10, &override)) {
768 ret = adjust_vdd(override);
769 if (ret < 0)
770 return CMD_RET_FAILURE;
771 } else
772 return CMD_RET_USAGE;
773 return 0;
774}
775
776static int do_vdd_read(struct cmd_tbl *cmdtp, int flag, int argc,
777 char *const argv[])
778{
779 if (argc < 1)
780 return CMD_RET_USAGE;
781 print_vdd();
782
783 return 0;
784}
785
786U_BOOT_CMD(
787 vdd_override, 2, 0, do_vdd_override,
788 "override VDD",
789 " - override with the voltage specified in mV, eg. 1050"
790);
791
792U_BOOT_CMD(
793 vdd_read, 1, 0, do_vdd_read,
794 "read VDD",
795 " - Read the voltage specified in mV"
796)
797