vid.c 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright 2014 Freescale Semiconductor, Inc.
  4. * Copyright 2020-21 NXP
  5. * Copyright 2020 Stephen Carlson <stcarlso@linux.microsoft.com>
  6. */
  7. #include <common.h>
  8. #include <command.h>
  9. #include <env.h>
  10. #include <i2c.h>
  11. #include <irq_func.h>
  12. #include <log.h>
  13. #include <asm/io.h>
  14. #ifdef CONFIG_FSL_LSCH2
  15. #include <asm/arch/immap_lsch2.h>
  16. #elif defined(CONFIG_FSL_LSCH3)
  17. #include <asm/arch/immap_lsch3.h>
  18. #else
  19. #include <asm/immap_85xx.h>
  20. #endif
  21. #include <linux/delay.h>
  22. #include "vid.h"
  23. /* Voltages are generally handled in mV to keep them as integers */
  24. #define MV_PER_V 1000
  25. /*
  26. * Select the channel on the I2C mux (on some NXP boards) that contains
  27. * the voltage regulator to use for VID. Return 0 for success or nonzero
  28. * for failure.
  29. */
  30. int __weak i2c_multiplexer_select_vid_channel(u8 channel)
  31. {
  32. return 0;
  33. }
  34. /*
  35. * Compensate for a board specific voltage drop between regulator and SoC.
  36. * Returns the voltage offset in mV.
  37. */
  38. int __weak board_vdd_drop_compensation(void)
  39. {
  40. return 0;
  41. }
  42. /*
  43. * Performs any board specific adjustments after the VID voltage has been
  44. * set. Return 0 for success or nonzero for failure.
  45. */
  46. int __weak board_adjust_vdd(int vdd)
  47. {
  48. return 0;
  49. }
  50. /*
  51. * Processor specific method of converting the fuse value read from VID
  52. * registers into the core voltage to supply. Return the voltage in mV.
  53. */
  54. u16 __weak soc_get_fuse_vid(int vid_index)
  55. {
  56. /* Default VDD for Layerscape Chassis 1 devices */
  57. static const u16 vdd[32] = {
  58. 0, /* unused */
  59. 9875, /* 0.9875V */
  60. 9750,
  61. 9625,
  62. 9500,
  63. 9375,
  64. 9250,
  65. 9125,
  66. 9000,
  67. 8875,
  68. 8750,
  69. 8625,
  70. 8500,
  71. 8375,
  72. 8250,
  73. 8125,
  74. 10000, /* 1.0000V */
  75. 10125,
  76. 10250,
  77. 10375,
  78. 10500,
  79. 10625,
  80. 10750,
  81. 10875,
  82. 11000,
  83. 0, /* reserved */
  84. };
  85. return vdd[vid_index];
  86. }
  87. #ifndef I2C_VOL_MONITOR_ADDR
  88. #define I2C_VOL_MONITOR_ADDR 0
  89. #endif
  90. #if CONFIG_IS_ENABLED(DM_I2C)
  91. #define DEVICE_HANDLE_T struct udevice *
  92. #ifndef I2C_VOL_MONITOR_BUS
  93. #define I2C_VOL_MONITOR_BUS 0
  94. #endif
  95. /* If DM is in use, retrieve the udevice chip for the specified bus number */
  96. static int vid_get_device(int address, DEVICE_HANDLE_T *dev)
  97. {
  98. int ret = i2c_get_chip_for_busnum(I2C_VOL_MONITOR_BUS, address, 1, dev);
  99. if (ret)
  100. printf("VID: Bus %d has no device with address 0x%02X\n",
  101. I2C_VOL_MONITOR_BUS, address);
  102. return ret;
  103. }
  104. #define I2C_READ(dev, register, data, length) \
  105. dm_i2c_read(dev, register, data, length)
  106. #define I2C_WRITE(dev, register, data, length) \
  107. dm_i2c_write(dev, register, data, length)
  108. #else
  109. #define DEVICE_HANDLE_T int
  110. /* If DM is not in use, I2C addresses are passed directly */
  111. static int vid_get_device(int address, DEVICE_HANDLE_T *dev)
  112. {
  113. *dev = address;
  114. return 0;
  115. }
  116. #define I2C_READ(dev, register, data, length) \
  117. i2c_read(dev, register, 1, data, length)
  118. #define I2C_WRITE(dev, register, data, length) \
  119. i2c_write(dev, register, 1, data, length)
  120. #endif
  121. #if defined(CONFIG_VOL_MONITOR_IR36021_SET) || \
  122. defined(CONFIG_VOL_MONITOR_IR36021_READ)
  123. /*
  124. * Get the i2c address configuration for the IR regulator chip
  125. *
  126. * There are some variance in the RDB HW regarding the I2C address configuration
  127. * for the IR regulator chip, which is likely a problem of external resistor
  128. * accuracy. So we just check each address in a hopefully non-intrusive mode
  129. * and use the first one that seems to work
  130. *
  131. * The IR chip can show up under the following addresses:
  132. * 0x08 (Verified on T1040RDB-PA,T4240RDB-PB,X-T4240RDB-16GPA)
  133. * 0x09 (Verified on T1040RDB-PA)
  134. * 0x38 (Verified on T2080QDS, T2081QDS, T4240RDB)
  135. */
  136. static int find_ir_chip_on_i2c(void)
  137. {
  138. int i2caddress, ret, i;
  139. u8 mfrID;
  140. const int ir_i2c_addr[] = {0x38, 0x08, 0x09};
  141. DEVICE_HANDLE_T dev;
  142. /* Check all the address */
  143. for (i = 0; i < (sizeof(ir_i2c_addr)/sizeof(ir_i2c_addr[0])); i++) {
  144. i2caddress = ir_i2c_addr[i];
  145. ret = vid_get_device(i2caddress, &dev);
  146. if (!ret) {
  147. ret = I2C_READ(dev, IR36021_MFR_ID_OFFSET,
  148. (void *)&mfrID, sizeof(mfrID));
  149. /* If manufacturer ID matches the IR36021 */
  150. if (!ret && mfrID == IR36021_MFR_ID)
  151. return i2caddress;
  152. }
  153. }
  154. return -1;
  155. }
  156. #endif
  157. /* Maximum loop count waiting for new voltage to take effect */
  158. #define MAX_LOOP_WAIT_NEW_VOL 100
  159. /* Maximum loop count waiting for the voltage to be stable */
  160. #define MAX_LOOP_WAIT_VOL_STABLE 100
  161. /*
  162. * read_voltage from sensor on I2C bus
  163. * We use average of 4 readings, waiting for WAIT_FOR_ADC before
  164. * another reading
  165. */
  166. #define NUM_READINGS 4 /* prefer to be power of 2 for efficiency */
  167. /* If an INA220 chip is available, we can use it to read back the voltage
  168. * as it may have a higher accuracy than the IR chip for the same purpose
  169. */
  170. #ifdef CONFIG_VOL_MONITOR_INA220
  171. #define WAIT_FOR_ADC 532 /* wait for 532 microseconds for ADC */
  172. #define ADC_MIN_ACCURACY 4
  173. #else
  174. #define WAIT_FOR_ADC 138 /* wait for 138 microseconds for ADC */
  175. #define ADC_MIN_ACCURACY 4
  176. #endif
  177. #ifdef CONFIG_VOL_MONITOR_INA220
  178. static int read_voltage_from_INA220(int i2caddress)
  179. {
  180. int i, ret, voltage_read = 0;
  181. u16 vol_mon;
  182. u8 buf[2];
  183. DEVICE_HANDLE_T dev;
  184. /* Open device handle */
  185. ret = vid_get_device(i2caddress, &dev);
  186. if (ret)
  187. return ret;
  188. for (i = 0; i < NUM_READINGS; i++) {
  189. ret = I2C_READ(dev, I2C_VOL_MONITOR_BUS_V_OFFSET,
  190. (void *)&buf[0], sizeof(buf));
  191. if (ret) {
  192. printf("VID: failed to read core voltage\n");
  193. return ret;
  194. }
  195. vol_mon = (buf[0] << 8) | buf[1];
  196. if (vol_mon & I2C_VOL_MONITOR_BUS_V_OVF) {
  197. printf("VID: Core voltage sensor error\n");
  198. return -1;
  199. }
  200. debug("VID: bus voltage reads 0x%04x\n", vol_mon);
  201. /* LSB = 4mv */
  202. voltage_read += (vol_mon >> I2C_VOL_MONITOR_BUS_V_SHIFT) * 4;
  203. udelay(WAIT_FOR_ADC);
  204. }
  205. /* calculate the average */
  206. voltage_read /= NUM_READINGS;
  207. return voltage_read;
  208. }
  209. #endif
  210. #ifdef CONFIG_VOL_MONITOR_IR36021_READ
  211. /* read voltage from IR */
  212. static int read_voltage_from_IR(int i2caddress)
  213. {
  214. int i, ret, voltage_read = 0;
  215. u16 vol_mon;
  216. u8 buf;
  217. DEVICE_HANDLE_T dev;
  218. /* Open device handle */
  219. ret = vid_get_device(i2caddress, &dev);
  220. if (ret)
  221. return ret;
  222. for (i = 0; i < NUM_READINGS; i++) {
  223. ret = I2C_READ(dev, IR36021_LOOP1_VOUT_OFFSET, (void *)&buf,
  224. sizeof(buf));
  225. if (ret) {
  226. printf("VID: failed to read core voltage\n");
  227. return ret;
  228. }
  229. vol_mon = buf;
  230. if (!vol_mon) {
  231. printf("VID: Core voltage sensor error\n");
  232. return -1;
  233. }
  234. debug("VID: bus voltage reads 0x%02x\n", vol_mon);
  235. /* Resolution is 1/128V. We scale up here to get 1/128mV
  236. * and divide at the end
  237. */
  238. voltage_read += vol_mon * MV_PER_V;
  239. udelay(WAIT_FOR_ADC);
  240. }
  241. /* Scale down to the real mV as IR resolution is 1/128V, rounding up */
  242. voltage_read = DIV_ROUND_UP(voltage_read, 128);
  243. /* calculate the average */
  244. voltage_read /= NUM_READINGS;
  245. /* Compensate for a board specific voltage drop between regulator and
  246. * SoC before converting into an IR VID value
  247. */
  248. voltage_read -= board_vdd_drop_compensation();
  249. return voltage_read;
  250. }
  251. #endif
  252. #if defined(CONFIG_VOL_MONITOR_ISL68233_READ) || \
  253. defined(CONFIG_VOL_MONITOR_LTC3882_READ) || \
  254. defined(CONFIG_VOL_MONITOR_ISL68233_SET) || \
  255. defined(CONFIG_VOL_MONITOR_LTC3882_SET)
  256. /*
  257. * The message displayed if the VOUT exponent causes a resolution
  258. * worse than 1.0 V (if exponent is >= 0).
  259. */
  260. #define VOUT_WARNING "VID: VOUT_MODE exponent has resolution worse than 1 V!\n"
  261. /* Checks the PMBus voltage monitor for the format used for voltage values */
  262. static int get_pmbus_multiplier(DEVICE_HANDLE_T dev)
  263. {
  264. u8 mode;
  265. int exponent, multiplier, ret;
  266. ret = I2C_READ(dev, PMBUS_CMD_VOUT_MODE, &mode, sizeof(mode));
  267. if (ret) {
  268. printf("VID: unable to determine voltage multiplier\n");
  269. return 1;
  270. }
  271. /* Upper 3 bits is mode, lower 5 bits is exponent */
  272. exponent = (int)mode & 0x1F;
  273. mode >>= 5;
  274. switch (mode) {
  275. case 0:
  276. /* Linear, 5 bit twos component exponent */
  277. if (exponent & 0x10) {
  278. multiplier = 1 << (16 - (exponent & 0xF));
  279. } else {
  280. /* If exponent is >= 0, then resolution is 1 V! */
  281. printf(VOUT_WARNING);
  282. multiplier = 1;
  283. }
  284. break;
  285. case 1:
  286. /* VID code identifier */
  287. printf("VID: custom VID codes are not supported\n");
  288. multiplier = MV_PER_V;
  289. break;
  290. default:
  291. /* Direct, in mV */
  292. multiplier = MV_PER_V;
  293. break;
  294. }
  295. debug("VID: calculated multiplier is %d\n", multiplier);
  296. return multiplier;
  297. }
  298. #endif
  299. #if defined(CONFIG_VOL_MONITOR_ISL68233_READ) || \
  300. defined(CONFIG_VOL_MONITOR_LTC3882_READ)
  301. static int read_voltage_from_pmbus(int i2caddress)
  302. {
  303. int ret, multiplier, vout;
  304. u8 channel = PWM_CHANNEL0;
  305. u16 vcode;
  306. DEVICE_HANDLE_T dev;
  307. /* Open device handle */
  308. ret = vid_get_device(i2caddress, &dev);
  309. if (ret)
  310. return ret;
  311. /* Select the right page */
  312. ret = I2C_WRITE(dev, PMBUS_CMD_PAGE, &channel, sizeof(channel));
  313. if (ret) {
  314. printf("VID: failed to select VDD page %d\n", channel);
  315. return ret;
  316. }
  317. /* VOUT is little endian */
  318. ret = I2C_READ(dev, PMBUS_CMD_READ_VOUT, (void *)&vcode, sizeof(vcode));
  319. if (ret) {
  320. printf("VID: failed to read core voltage\n");
  321. return ret;
  322. }
  323. /* Scale down to the real mV */
  324. multiplier = get_pmbus_multiplier(dev);
  325. vout = (int)vcode;
  326. /* Multiplier 1000 (direct mode) requires no change to convert */
  327. if (multiplier != MV_PER_V)
  328. vout = DIV_ROUND_UP(vout * MV_PER_V, multiplier);
  329. return vout - board_vdd_drop_compensation();
  330. }
  331. #endif
  332. static int read_voltage(int i2caddress)
  333. {
  334. int voltage_read;
  335. #ifdef CONFIG_VOL_MONITOR_INA220
  336. voltage_read = read_voltage_from_INA220(I2C_VOL_MONITOR_ADDR);
  337. #elif defined CONFIG_VOL_MONITOR_IR36021_READ
  338. voltage_read = read_voltage_from_IR(i2caddress);
  339. #elif defined(CONFIG_VOL_MONITOR_ISL68233_READ) || \
  340. defined(CONFIG_VOL_MONITOR_LTC3882_READ)
  341. voltage_read = read_voltage_from_pmbus(i2caddress);
  342. #else
  343. voltage_read = -1;
  344. #endif
  345. return voltage_read;
  346. }
  347. #ifdef CONFIG_VOL_MONITOR_IR36021_SET
  348. /*
  349. * We need to calculate how long before the voltage stops to drop
  350. * or increase. It returns with the loop count. Each loop takes
  351. * several readings (WAIT_FOR_ADC)
  352. */
  353. static int wait_for_new_voltage(int vdd, int i2caddress)
  354. {
  355. int timeout, vdd_current;
  356. vdd_current = read_voltage(i2caddress);
  357. /* wait until voltage starts to reach the target. Voltage slew
  358. * rates by typical regulators will always lead to stable readings
  359. * within each fairly long ADC interval in comparison to the
  360. * intended voltage delta change until the target voltage is
  361. * reached. The fairly small voltage delta change to any target
  362. * VID voltage also means that this function will always complete
  363. * within few iterations. If the timeout was ever reached, it would
  364. * point to a serious failure in the regulator system.
  365. */
  366. for (timeout = 0;
  367. abs(vdd - vdd_current) > (IR_VDD_STEP_UP + IR_VDD_STEP_DOWN) &&
  368. timeout < MAX_LOOP_WAIT_NEW_VOL; timeout++) {
  369. vdd_current = read_voltage(i2caddress);
  370. }
  371. if (timeout >= MAX_LOOP_WAIT_NEW_VOL) {
  372. printf("VID: Voltage adjustment timeout\n");
  373. return -1;
  374. }
  375. return timeout;
  376. }
  377. /*
  378. * Blocks and reads the VID voltage until it stabilizes, or the
  379. * timeout expires
  380. */
  381. static int wait_for_voltage_stable(int i2caddress)
  382. {
  383. int timeout, vdd_current, vdd;
  384. vdd = read_voltage(i2caddress);
  385. udelay(NUM_READINGS * WAIT_FOR_ADC);
  386. vdd_current = read_voltage(i2caddress);
  387. /*
  388. * The maximum timeout is
  389. * MAX_LOOP_WAIT_VOL_STABLE * NUM_READINGS * WAIT_FOR_ADC
  390. */
  391. for (timeout = MAX_LOOP_WAIT_VOL_STABLE;
  392. abs(vdd - vdd_current) > ADC_MIN_ACCURACY &&
  393. timeout > 0; timeout--) {
  394. vdd = vdd_current;
  395. udelay(NUM_READINGS * WAIT_FOR_ADC);
  396. vdd_current = read_voltage(i2caddress);
  397. }
  398. if (timeout == 0)
  399. return -1;
  400. return vdd_current;
  401. }
  402. /* Sets the VID voltage using the IR36021 */
  403. static int set_voltage_to_IR(int i2caddress, int vdd)
  404. {
  405. int wait, vdd_last;
  406. int ret;
  407. u8 vid;
  408. DEVICE_HANDLE_T dev;
  409. /* Open device handle */
  410. ret = vid_get_device(i2caddress, &dev);
  411. if (ret)
  412. return ret;
  413. /* Compensate for a board specific voltage drop between regulator and
  414. * SoC before converting into an IR VID value
  415. */
  416. vdd += board_vdd_drop_compensation();
  417. #ifdef CONFIG_FSL_LSCH2
  418. vid = DIV_ROUND_UP(vdd - 265, 5);
  419. #else
  420. vid = DIV_ROUND_UP(vdd - 245, 5);
  421. #endif
  422. ret = I2C_WRITE(dev, IR36021_LOOP1_MANUAL_ID_OFFSET, (void *)&vid,
  423. sizeof(vid));
  424. if (ret) {
  425. printf("VID: failed to write new voltage\n");
  426. return -1;
  427. }
  428. wait = wait_for_new_voltage(vdd, i2caddress);
  429. if (wait < 0)
  430. return -1;
  431. debug("VID: Waited %d us\n", wait * NUM_READINGS * WAIT_FOR_ADC);
  432. vdd_last = wait_for_voltage_stable(i2caddress);
  433. if (vdd_last < 0)
  434. return -1;
  435. debug("VID: Current voltage is %d mV\n", vdd_last);
  436. return vdd_last;
  437. }
  438. #endif
  439. #if defined(CONFIG_VOL_MONITOR_ISL68233_SET) || \
  440. defined(CONFIG_VOL_MONITOR_LTC3882_SET)
  441. static int set_voltage_to_pmbus(int i2caddress, int vdd)
  442. {
  443. int ret, vdd_last, vdd_target = vdd;
  444. int count = MAX_LOOP_WAIT_NEW_VOL, temp = 0, multiplier;
  445. unsigned char value;
  446. /* The data to be sent with the PMBus command PAGE_PLUS_WRITE */
  447. u8 buffer[5] = { 0x04, PWM_CHANNEL0, PMBUS_CMD_VOUT_COMMAND, 0, 0 };
  448. DEVICE_HANDLE_T dev;
  449. /* Open device handle */
  450. ret = vid_get_device(i2caddress, &dev);
  451. if (ret)
  452. return ret;
  453. /* Scale up to the proper value for the VOUT command, little endian */
  454. multiplier = get_pmbus_multiplier(dev);
  455. vdd += board_vdd_drop_compensation();
  456. if (multiplier != MV_PER_V)
  457. vdd = DIV_ROUND_UP(vdd * multiplier, MV_PER_V);
  458. buffer[3] = vdd & 0xFF;
  459. buffer[4] = (vdd & 0xFF00) >> 8;
  460. /* Check write protect state */
  461. ret = I2C_READ(dev, PMBUS_CMD_WRITE_PROTECT, (void *)&value,
  462. sizeof(value));
  463. if (ret)
  464. goto exit;
  465. if (value != EN_WRITE_ALL_CMD) {
  466. value = EN_WRITE_ALL_CMD;
  467. ret = I2C_WRITE(dev, PMBUS_CMD_WRITE_PROTECT,
  468. (void *)&value, sizeof(value));
  469. if (ret)
  470. goto exit;
  471. }
  472. /* Write the desired voltage code to the regulator */
  473. ret = I2C_WRITE(dev, PMBUS_CMD_PAGE_PLUS_WRITE, (void *)&buffer[0],
  474. sizeof(buffer));
  475. if (ret) {
  476. printf("VID: I2C failed to write to the voltage regulator\n");
  477. return -1;
  478. }
  479. exit:
  480. /* Wait for the voltage to get to the desired value */
  481. do {
  482. vdd_last = read_voltage_from_pmbus(i2caddress);
  483. if (vdd_last < 0) {
  484. printf("VID: Couldn't read sensor abort VID adjust\n");
  485. return -1;
  486. }
  487. count--;
  488. temp = vdd_last - vdd_target;
  489. } while ((abs(temp) > 2) && (count > 0));
  490. return vdd_last;
  491. }
  492. #endif
  493. static int set_voltage(int i2caddress, int vdd)
  494. {
  495. int vdd_last = -1;
  496. #ifdef CONFIG_VOL_MONITOR_IR36021_SET
  497. vdd_last = set_voltage_to_IR(i2caddress, vdd);
  498. #elif defined(CONFIG_VOL_MONITOR_ISL68233_SET) || \
  499. defined(CONFIG_VOL_MONITOR_LTC3882_SET)
  500. vdd_last = set_voltage_to_pmbus(i2caddress, vdd);
  501. #else
  502. #error Specific voltage monitor must be defined
  503. #endif
  504. return vdd_last;
  505. }
  506. int adjust_vdd(ulong vdd_override)
  507. {
  508. int re_enable = disable_interrupts();
  509. #if defined(CONFIG_FSL_LSCH2) || defined(CONFIG_FSL_LSCH3)
  510. struct ccsr_gur *gur = (void *)(CONFIG_SYS_FSL_GUTS_ADDR);
  511. #else
  512. ccsr_gur_t __iomem *gur =
  513. (void __iomem *)(CONFIG_SYS_MPC85xx_GUTS_ADDR);
  514. #endif
  515. u8 vid;
  516. u32 fusesr;
  517. int vdd_current, vdd_last, vdd_target;
  518. int ret, i2caddress = I2C_VOL_MONITOR_ADDR;
  519. unsigned long vdd_string_override;
  520. char *vdd_string;
  521. #if defined(CONFIG_VOL_MONITOR_IR36021_SET) || \
  522. defined(CONFIG_VOL_MONITOR_IR36021_READ)
  523. u8 buf;
  524. DEVICE_HANDLE_T dev;
  525. #endif
  526. /*
  527. * VID is used according to the table below
  528. * ---------------------------------------
  529. * | DA_V |
  530. * |-------------------------------------|
  531. * | 5b00000 | 5b00001-5b11110 | 5b11111 |
  532. * ---------------+---------+-----------------+---------|
  533. * | D | 5b00000 | NO VID | VID = DA_V | NO VID |
  534. * | A |----------+---------+-----------------+---------|
  535. * | _ | 5b00001 |VID = | VID = |VID = |
  536. * | V | ~ | DA_V_ALT| DA_V_ALT | DA_A_VLT|
  537. * | _ | 5b11110 | | | |
  538. * | A |----------+---------+-----------------+---------|
  539. * | L | 5b11111 | No VID | VID = DA_V | NO VID |
  540. * | T | | | | |
  541. * ------------------------------------------------------
  542. */
  543. #if defined(CONFIG_FSL_LSCH3)
  544. fusesr = in_le32(&gur->dcfg_fusesr);
  545. vid = (fusesr >> FSL_CHASSIS3_DCFG_FUSESR_ALTVID_SHIFT) &
  546. FSL_CHASSIS3_DCFG_FUSESR_ALTVID_MASK;
  547. if (vid == 0 || vid == FSL_CHASSIS3_DCFG_FUSESR_ALTVID_MASK) {
  548. vid = (fusesr >> FSL_CHASSIS3_DCFG_FUSESR_VID_SHIFT) &
  549. FSL_CHASSIS3_DCFG_FUSESR_VID_MASK;
  550. }
  551. #elif defined(CONFIG_FSL_LSCH2)
  552. fusesr = in_be32(&gur->dcfg_fusesr);
  553. vid = (fusesr >> FSL_CHASSIS2_DCFG_FUSESR_ALTVID_SHIFT) &
  554. FSL_CHASSIS2_DCFG_FUSESR_ALTVID_MASK;
  555. if (vid == 0 || vid == FSL_CHASSIS2_DCFG_FUSESR_ALTVID_MASK) {
  556. vid = (fusesr >> FSL_CHASSIS2_DCFG_FUSESR_VID_SHIFT) &
  557. FSL_CHASSIS2_DCFG_FUSESR_VID_MASK;
  558. }
  559. #else
  560. fusesr = in_be32(&gur->dcfg_fusesr);
  561. vid = (fusesr >> FSL_CORENET_DCFG_FUSESR_ALTVID_SHIFT) &
  562. FSL_CORENET_DCFG_FUSESR_ALTVID_MASK;
  563. if (vid == 0 || vid == FSL_CORENET_DCFG_FUSESR_ALTVID_MASK) {
  564. vid = (fusesr >> FSL_CORENET_DCFG_FUSESR_VID_SHIFT) &
  565. FSL_CORENET_DCFG_FUSESR_VID_MASK;
  566. }
  567. #endif
  568. vdd_target = soc_get_fuse_vid((int)vid);
  569. ret = i2c_multiplexer_select_vid_channel(I2C_MUX_CH_VOL_MONITOR);
  570. if (ret) {
  571. debug("VID: I2C failed to switch channel\n");
  572. ret = -1;
  573. goto exit;
  574. }
  575. #if defined(CONFIG_VOL_MONITOR_IR36021_SET) || \
  576. defined(CONFIG_VOL_MONITOR_IR36021_READ)
  577. ret = find_ir_chip_on_i2c();
  578. if (ret < 0) {
  579. printf("VID: Could not find voltage regulator on I2C.\n");
  580. ret = -1;
  581. goto exit;
  582. } else {
  583. i2caddress = ret;
  584. debug("VID: IR Chip found on I2C address 0x%02x\n", i2caddress);
  585. }
  586. ret = vid_get_device(i2caddress, &dev);
  587. if (ret)
  588. return ret;
  589. /* check IR chip work on Intel mode */
  590. ret = I2C_READ(dev, IR36021_INTEL_MODE_OFFSET, (void *)&buf,
  591. sizeof(buf));
  592. if (ret) {
  593. printf("VID: failed to read IR chip mode.\n");
  594. ret = -1;
  595. goto exit;
  596. }
  597. if ((buf & IR36021_MODE_MASK) != IR36021_INTEL_MODE) {
  598. printf("VID: IR Chip is not used in Intel mode.\n");
  599. ret = -1;
  600. goto exit;
  601. }
  602. #endif
  603. /* check override variable for overriding VDD */
  604. vdd_string = env_get(CONFIG_VID_FLS_ENV);
  605. debug("VID: Initial VDD value is %d mV\n",
  606. DIV_ROUND_UP(vdd_target, 10));
  607. if (vdd_override == 0 && vdd_string &&
  608. !strict_strtoul(vdd_string, 10, &vdd_string_override))
  609. vdd_override = vdd_string_override;
  610. if (vdd_override >= VDD_MV_MIN && vdd_override <= VDD_MV_MAX) {
  611. vdd_target = vdd_override * 10; /* convert to 1/10 mV */
  612. debug("VID: VDD override is %lu\n", vdd_override);
  613. } else if (vdd_override != 0) {
  614. printf("VID: Invalid VDD value.\n");
  615. }
  616. if (vdd_target == 0) {
  617. debug("VID: VID not used\n");
  618. ret = 0;
  619. goto exit;
  620. } else {
  621. /* divide and round up by 10 to get a value in mV */
  622. vdd_target = DIV_ROUND_UP(vdd_target, 10);
  623. debug("VID: vid = %d mV\n", vdd_target);
  624. }
  625. /*
  626. * Read voltage monitor to check real voltage.
  627. */
  628. vdd_last = read_voltage(i2caddress);
  629. if (vdd_last < 0) {
  630. printf("VID: Couldn't read sensor abort VID adjustment\n");
  631. ret = -1;
  632. goto exit;
  633. }
  634. vdd_current = vdd_last;
  635. debug("VID: Core voltage is currently at %d mV\n", vdd_last);
  636. #if defined(CONFIG_VOL_MONITOR_LTC3882_SET) || \
  637. defined(CONFIG_VOL_MONITOR_ISL68233_SET)
  638. /* Set the target voltage */
  639. vdd_current = set_voltage(i2caddress, vdd_target);
  640. vdd_last = vdd_current;
  641. #else
  642. /*
  643. * Adjust voltage to at or one step above target.
  644. * As measurements are less precise than setting the values
  645. * we may run through dummy steps that cancel each other
  646. * when stepping up and then down.
  647. */
  648. while (vdd_last > 0 &&
  649. vdd_last < vdd_target) {
  650. vdd_current += IR_VDD_STEP_UP;
  651. vdd_last = set_voltage(i2caddress, vdd_current);
  652. }
  653. while (vdd_last > 0 &&
  654. vdd_last > vdd_target + (IR_VDD_STEP_DOWN - 1)) {
  655. vdd_current -= IR_VDD_STEP_DOWN;
  656. vdd_last = set_voltage(i2caddress, vdd_current);
  657. }
  658. #endif
  659. /* Board specific adjustments */
  660. if (board_adjust_vdd(vdd_target) < 0) {
  661. ret = -1;
  662. goto exit;
  663. }
  664. if (vdd_last > 0)
  665. printf("VID: Core voltage after adjustment is at %d mV\n",
  666. vdd_last);
  667. else
  668. ret = -1;
  669. exit:
  670. if (re_enable)
  671. enable_interrupts();
  672. i2c_multiplexer_select_vid_channel(I2C_MUX_CH_DEFAULT);
  673. return ret;
  674. }
  675. static int print_vdd(void)
  676. {
  677. int vdd_last, ret, i2caddress = I2C_VOL_MONITOR_ADDR;
  678. ret = i2c_multiplexer_select_vid_channel(I2C_MUX_CH_VOL_MONITOR);
  679. if (ret) {
  680. debug("VID : I2c failed to switch channel\n");
  681. return -1;
  682. }
  683. #if defined(CONFIG_VOL_MONITOR_IR36021_SET) || \
  684. defined(CONFIG_VOL_MONITOR_IR36021_READ)
  685. ret = find_ir_chip_on_i2c();
  686. if (ret < 0) {
  687. printf("VID: Could not find voltage regulator on I2C.\n");
  688. goto exit;
  689. } else {
  690. i2caddress = ret;
  691. debug("VID: IR Chip found on I2C address 0x%02x\n", i2caddress);
  692. }
  693. #endif
  694. /*
  695. * Read voltage monitor to check real voltage.
  696. */
  697. vdd_last = read_voltage(i2caddress);
  698. if (vdd_last < 0) {
  699. printf("VID: Couldn't read sensor abort VID adjustment\n");
  700. goto exit;
  701. }
  702. printf("VID: Core voltage is at %d mV\n", vdd_last);
  703. exit:
  704. i2c_multiplexer_select_vid_channel(I2C_MUX_CH_DEFAULT);
  705. return ret < 0 ? -1 : 0;
  706. }
  707. static int do_vdd_override(struct cmd_tbl *cmdtp,
  708. int flag, int argc,
  709. char *const argv[])
  710. {
  711. ulong override;
  712. int ret = 0;
  713. if (argc < 2)
  714. return CMD_RET_USAGE;
  715. if (!strict_strtoul(argv[1], 10, &override)) {
  716. ret = adjust_vdd(override);
  717. if (ret < 0)
  718. return CMD_RET_FAILURE;
  719. } else
  720. return CMD_RET_USAGE;
  721. return 0;
  722. }
  723. static int do_vdd_read(struct cmd_tbl *cmdtp, int flag, int argc,
  724. char *const argv[])
  725. {
  726. if (argc < 1)
  727. return CMD_RET_USAGE;
  728. print_vdd();
  729. return 0;
  730. }
  731. U_BOOT_CMD(
  732. vdd_override, 2, 0, do_vdd_override,
  733. "override VDD",
  734. " - override with the voltage specified in mV, eg. 1050"
  735. );
  736. U_BOOT_CMD(
  737. vdd_read, 1, 0, do_vdd_read,
  738. "read VDD",
  739. " - Read the voltage specified in mV"
  740. )