1 /*
2 * Copyright 2023-2024 NXP
3 * All rights reserved.
4 *
5 * SPDX-License-Identifier: BSD-3-Clause
6 */
7
8 #include "fsl_common.h"
9 #include "fsl_pca9422.h"
10 #include "fsl_power.h"
11 /*******************************************************************************
12 * Definitions
13 ******************************************************************************/
14 #if defined(FSL_DEBUG_PMIC_DRIVER) && (FSL_DEBUG_PMIC_DRIVER != 0U)
15 #include "fsl_debug_console.h"
16 #define LOG_INFO PRINTF
17 #else
18 #define LOG_INFO(...)
19 #endif
20
21 /*******************************************************************************
22 * Prototypes
23 ******************************************************************************/
24 static uint64_t pca9422_ffs(uint64_t word);
25
26 #define MASK2SHIFT(_mask) pca9422_ffs(_mask)
27 /*******************************************************************************
28 * Variables
29 ******************************************************************************/
30
31 /*******************************************************************************
32 * Code
33 ******************************************************************************/
pca9422_ffs(uint64_t word)34 static uint64_t pca9422_ffs(uint64_t word)
35 {
36 uint32_t num = 0U;
37
38 if ((word & 0xffffffffU) == 0U)
39 {
40 num += 32U;
41 word >>= 32U;
42 }
43 if ((word & 0xffffU) == 0U)
44 {
45 num += 16U;
46 word >>= 16U;
47 }
48 if ((word & 0xffU) == 0U)
49 {
50 num += 8U;
51 word >>= 8U;
52 }
53 if ((word & 0xfU) == 0U)
54 {
55 num += 4U;
56 word >>= 4U;
57 }
58 if ((word & 0x3U) == 0U)
59 {
60 num += 2U;
61 word >>= 2U;
62 }
63 if ((word & 0x1U) == 0U)
64 {
65 num += 1U;
66 }
67 return (uint64_t)num;
68 }
69
PCA9422_GetChargerDefaultConfig(pca9422_charger_config_t * config)70 void PCA9422_GetChargerDefaultConfig(pca9422_charger_config_t *config)
71 {
72 assert(config);
73
74 /* Set callback function to NULL Pointer. */
75 config->I2C_SendFunc = NULL;
76 config->I2C_ReceiveFunc = NULL;
77
78 /* Precharge current set to 20% of fast charge current. */
79 config->prechgI = kPCA9422_PrechgI20percent;
80 /* Current step is 2.5mA. */
81 config->chgIStep = kPCA9422_ChgIStep2p5mA;
82 /* Top-off current is 2.5% of fast charge current. */
83 config->topoffI = kPCA9422_TopoffI2p5percent;
84 /* Fast charge current is 100mA. */
85 config->fastI = 100U;
86 /* VBAT regulation voltage is 4200mV. */
87 config->vbatReg = 4200U;
88 /* Recharge voltage threshold is [VBAT_REG - 100mV]. */
89 config->rechgVolt = kPCA9422_RechargeTh100mV;
90 /* Precharge timer is 30minutes. */
91 config->prechgTime = kPCA9422_PrechgTimer30min;
92 /* Fast charge timer is 3hours. */
93 config->fastchgTime = kPCA9422_FastchgTimer3h;
94 /* Top-off timer is 5minutes. */
95 config->topoffTime = kPCA9422_TopoffTimer5min;
96 /* Warm(40C) voltage threshold is 32.63% of VL. */
97 config->warmVolt = kPCA9422_Vwarm45C32p63percent;
98 /* Warm Plus(50C) voltage threshold is 29.07% of VL. */
99 config->warmPlusVolt = kPCA9422_Vwarm50C29p07percent;
100 /* Hot(60C) voltage threshold is 22.94% of VL. */
101 config->hotVolt = kPCA9422_Vhot60C22p94percent;
102 /* Cool(10C) voltage threshold is 64.82% of VL. */
103 config->coolVolt = kPCA9422_Vcool10C64p82percent;
104 /* Cold(0C) voltage threshold is 74.18% of VL. */
105 config->coldVolt = kPCA9422_Vcold0C74p18percent;
106 /* New VBAT_REG voltage at WARM(40C) stays VBAT_REG. */
107 config->warmVbatReg = kPCA9422_NewVbat45C_StayVbatReg;
108 /* New VBAT_REG voltage at WARM_PLUS(50C) stays VBAT_REG. */
109 config->warmPlusVbatReg = kPCA9422_NewVbat50C_StayVbatReg;
110 /* New I_VBAT current at COOL(10C) stays I_FAST_CHG. */
111 config->coldIVbat = kPCA9422_NewIVbat10C_StayIFastchg;
112 /* New I_VBAT current at WARM(45C) stays I_FAST_CHG. */
113 config->warmIVbat = kPCA9422_NewIVbat45C_StayIFastchg;
114 /* New I_VBAT current at WARM_PLUS(50C) stays I_FAST_CHG. */
115 config->warmPlusIVbat = kPCA9422_NewIVbat50C_StayIFastchg;
116 /* AICL threshold on CHGIN is 4.5V. */
117 config->aiclV = kPCA9422_AICLV4p5V;
118 /* Input current limit on CHGIN is 470mA. */
119 config->icl = kPCA9422_ChgInIlim_470mA;
120 /* VSYS regulation voltage is 4550mV. */
121 config->vsysReg = 4550U;
122 /* AMUX wait time */
123 config->amuxWaitTime = kPCA9422_AMUXAutoOffWait_256us;
124 /* AMUX mode */
125 config->amuxMode = kPCA9422_AMUXModeManual;
126 /* VBAT/VSYS channel scale factor */
127 config->amuxVbatGain = kPCA9422_AMUXVbatVsysGain_1dvd3;
128 /* THERM and THERM_BIAS channels scale factor */
129 config->amuxThermGain = kPCA9422_AMUXThermGain_1;
130 /* AMUX channel */
131 config->amuxChannel = kPCA9422_AMUXChannel_Off;
132 /* I2C slave address. */
133 config->slaveAddress = PCA9422_DEFAULT_I2C_ADDR;
134 }
135
PCA9422_InitCharger(pca9422_handle_t * handle,const pca9422_charger_config_t * config)136 void PCA9422_InitCharger(pca9422_handle_t *handle, const pca9422_charger_config_t *config)
137 {
138 uint8_t chgCntl[11], chgInCntl[4], regVal;
139 bool result;
140
141 assert(handle);
142 assert(config);
143
144 /* Initialize Callback functions. */
145 handle->I2C_SendFunc = config->I2C_SendFunc;
146 handle->I2C_ReceiveFunc = config->I2C_ReceiveFunc;
147 /* Set Slave Address. */
148 handle->slaveAddress = config->slaveAddress;
149
150 /* Initialize Charger control registers */
151 chgCntl[0] = PCA9422_CHARGER_LOCK_UNLOCK;
152 chgCntl[1] = (uint8_t)(PCA9422_CHARGER_CNTL_1_AUTOSTOP_CHG_EN | PCA9422_CHARGER_CNTL_1_CHARGER_EN |
153 (uint8_t)config->warmPlusVolt | (uint8_t)config->prechgI | (uint8_t)config->chgIStep);
154 chgCntl[2] = (uint8_t)(PCA9422_VBAT_REG(config->vbatReg));
155 chgCntl[3] = (uint8_t)PCA9422_I_FAST_CHG_DFT;
156 chgCntl[4] = (uint8_t)((uint8_t)config->rechgVolt | (uint8_t)config->topoffI | (uint8_t)config->prechgTime);
157 chgCntl[5] = (uint8_t)PCA9422_CHARGER_CNTL_5_DFT;
158 chgCntl[6] = (uint8_t)((uint8_t)config->hotVolt | (uint8_t)config->warmVolt | (uint8_t)config->coolVolt |
159 (uint8_t)config->coldVolt);
160 chgCntl[7] = (uint8_t)(PCA9422_CHARGER_CNTL_7_CHG_DISABLE_AT_COLD_HOT_EN | (uint8_t)config->fastchgTime |
161 (uint8_t)config->coldIVbat | (uint8_t)config->warmVbatReg);
162 chgCntl[8] = (uint8_t)(config->topoffTime);
163 chgCntl[9] =
164 (uint8_t)((uint8_t)config->warmPlusVbatReg | (uint8_t)config->warmPlusIVbat | (uint8_t)config->warmIVbat);
165 chgCntl[10] = (uint8_t)((uint8_t)config->amuxWaitTime | (uint8_t)config->amuxMode | (uint8_t)config->amuxVbatGain |
166 (uint8_t)config->amuxThermGain | (uint8_t)config->amuxChannel);
167
168 result = PCA9422_WriteRegs(handle, PCA9422_CHG_CNTL0, chgCntl, sizeof(chgCntl));
169 regVal = PCA9422_CHARGER_LOCK_LOCK;
170 result = result ? PCA9422_WriteRegs(handle, PCA9422_CHG_CNTL0, ®Val, 1U) : result;
171 if (!result)
172 {
173 assert(false);
174 }
175
176 chgInCntl[0] = (uint8_t)PCA9422_CHGIN_CNTL_O_CHGIN_PD_EN;
177 chgInCntl[1] = (uint8_t)((uint8_t)config->aiclV | PCa9422_CHGIN_CNTL_1_AICL_EN);
178 chgInCntl[2] = (uint8_t)(config->icl);
179 chgInCntl[3] = (uint8_t)(PCA9422_VSYS_REG(config->vsysReg) << MASK2SHIFT(PCA9422_CHGIN_CNTL_3_VSYS_REG));
180 result = PCA9422_WriteRegs(handle, PCA9422_CHGIN_CNTL_0, chgInCntl, sizeof(chgInCntl));
181 if (!result)
182 {
183 assert(false);
184 }
185 }
186
PCA9422_SetPreChargeCurrent(pca9422_handle_t * handle,uint8_t iPrechg)187 bool PCA9422_SetPreChargeCurrent(pca9422_handle_t *handle, uint8_t iPrechg)
188 {
189 uint8_t regVal;
190 bool result = true;
191
192 /* Write CHARGER_LOCK bit */
193 regVal = PCA9422_CHARGER_LOCK_UNLOCK;
194 result = PCA9422_WriteRegs(handle, PCA9422_CHG_CNTL0, ®Val, 1U);
195 if (result == false)
196 {
197 goto error;
198 }
199
200 /* Set precharge current */
201 regVal = iPrechg;
202 result = PCA9422_ModifyReg(handle, PCA9422_CHG_CNTL1, PCA9422_CHARGER_CNTL_1_PRECHG_CURRENT, regVal);
203 if (result == false)
204 {
205 goto error;
206 }
207
208 /* Write CHARGER_LOCK bit */
209 regVal = PCA9422_CHARGER_LOCK_LOCK;
210 result = PCA9422_WriteRegs(handle, PCA9422_CHG_CNTL0, ®Val, 1U);
211
212 error:
213 return result;
214 }
215
PCA9422_GetPreChargeCurrent(pca9422_handle_t * handle)216 uint8_t PCA9422_GetPreChargeCurrent(pca9422_handle_t *handle)
217 {
218 uint8_t regVal;
219 uint8_t iPrechg;
220 bool result = true;
221
222 /* Write CHARGER_LOCK bit */
223 regVal = PCA9422_CHARGER_LOCK_UNLOCK;
224 result = PCA9422_WriteRegs(handle, PCA9422_CHG_CNTL0, ®Val, 1U);
225 if (!result)
226 {
227 LOG_INFO("Error in I2C operation in %s.", __func__);
228 }
229
230 /* Read CHG_CNTL_1 */
231 result = PCA9422_ReadRegs(handle, PCA9422_CHG_CNTL1, ®Val, 1U);
232 if (!result)
233 {
234 LOG_INFO("Error in I2C operation in %s.", __func__);
235 }
236 iPrechg = (regVal & PCA9422_CHARGER_CNTL_1_PRECHG_CURRENT);
237
238 /* Write CHARGER_LOCK bit */
239 regVal = PCA9422_CHARGER_LOCK_LOCK;
240 result = PCA9422_WriteRegs(handle, PCA9422_CHG_CNTL0, ®Val, 1U);
241 if (!result)
242 {
243 LOG_INFO("Error in I2C operation in %s.", __func__);
244 }
245
246 return iPrechg;
247 }
248
PCA9422_SetTopoffCurrent(pca9422_handle_t * handle,uint8_t iTopoff)249 bool PCA9422_SetTopoffCurrent(pca9422_handle_t *handle, uint8_t iTopoff)
250 {
251 uint8_t regVal;
252 bool result = true;
253
254 /* Write CHARGER_LOCK bit */
255 regVal = PCA9422_CHARGER_LOCK_UNLOCK;
256 result = PCA9422_WriteRegs(handle, PCA9422_CHG_CNTL0, ®Val, 1U);
257 if (result == false)
258 {
259 goto error;
260 }
261
262 /* Set topoff current */
263 regVal = iTopoff;
264 result = PCA9422_ModifyReg(handle, PCA9422_CHG_CNTL4, PCA9422_CHARGER_CNTL_4_TOPOFF_CURRENT, regVal);
265 if (result == false)
266 {
267 goto error;
268 }
269
270 /* Write CHARGER_LOCK bit */
271 regVal = PCA9422_CHARGER_LOCK_LOCK;
272 result = PCA9422_WriteRegs(handle, PCA9422_CHG_CNTL0, ®Val, 1U);
273
274 error:
275 return result;
276 }
277
PCA9422_GetTopoffCurrent(pca9422_handle_t * handle)278 uint8_t PCA9422_GetTopoffCurrent(pca9422_handle_t *handle)
279 {
280 uint8_t regVal;
281 uint8_t iTopoff = 0U;
282 bool result;
283
284 /* Write CHARGER_LOCK bit */
285 regVal = PCA9422_CHARGER_LOCK_UNLOCK;
286 result = PCA9422_WriteRegs(handle, PCA9422_CHG_CNTL0, ®Val, 1U);
287 if (result == true)
288 {
289 /* Read CHG_CNTL_4 */
290 result = PCA9422_ReadRegs(handle, PCA9422_CHG_CNTL4, ®Val, 1U);
291 iTopoff = (regVal & PCA9422_CHARGER_CNTL_4_TOPOFF_CURRENT);
292 }
293 if (result == true)
294 {
295 /* Write CHARGER_LOCK bit */
296 regVal = PCA9422_CHARGER_LOCK_LOCK;
297 result = PCA9422_WriteRegs(handle, PCA9422_CHG_CNTL0, ®Val, 1U);
298 }
299 assert(result == true);
300
301 return iTopoff;
302 }
303
PCA9422_SetFastChargeCurrent(pca9422_handle_t * handle,uint16_t iFast)304 bool PCA9422_SetFastChargeCurrent(pca9422_handle_t *handle, uint16_t iFast)
305 {
306 uint8_t currStep;
307 uint8_t regVal;
308 bool result;
309
310 /* Write CHARGER_LOCK bit */
311 regVal = PCA9422_CHARGER_LOCK_UNLOCK;
312 result = PCA9422_WriteRegs(handle, PCA9422_CHG_CNTL0, ®Val, 1U);
313 if (result == false)
314 {
315 goto error;
316 }
317
318 /* Check charging current */
319 if (iFast > 320U * 10U)
320 {
321 /* Set current step to 5mA */
322 regVal = (uint8_t)kPCA9422_ChgIStep5p0mA;
323 }
324 else
325 {
326 /* Set current step to 2.5mA */
327 regVal = (uint8_t)kPCA9422_ChgIStep2p5mA;
328 }
329 result = PCA9422_ModifyReg(handle, PCA9422_CHG_CNTL1, PCA9422_CHARGER_CNTL_1_CHG_CURRENT_STEP, regVal);
330 if (result == false)
331 {
332 goto error;
333 }
334 /* Get current step */
335 currStep = (regVal == (uint8_t)kPCA9422_ChgIStep5p0mA) ? 50U : 25U;
336 regVal = (uint8_t)((iFast - currStep) / currStep);
337
338 /* Set I_FAST_CHG */
339 result = PCA9422_WriteRegs(handle, PCA9422_CHG_CNTL3, ®Val, 1U);
340 if (result == false)
341 {
342 goto error;
343 }
344
345 /* Write CHARGER_LOCK bit */
346 regVal = PCA9422_CHARGER_LOCK_LOCK;
347 result = PCA9422_WriteRegs(handle, PCA9422_CHG_CNTL0, ®Val, 1U);
348
349 error:
350 return result;
351 }
352
PCA9422_GetFastChargeCurrent(pca9422_handle_t * handle)353 uint16_t PCA9422_GetFastChargeCurrent(pca9422_handle_t *handle)
354 {
355 uint8_t currStep;
356 uint8_t regVal;
357 uint16_t iFastReg;
358 bool result = true;
359
360 /* Write CHARGER_LOCK bit */
361 regVal = PCA9422_CHARGER_LOCK_UNLOCK;
362 result = PCA9422_WriteRegs(handle, PCA9422_CHG_CNTL0, ®Val, 1U);
363 if (!result)
364 {
365 LOG_INFO("Error in I2C operation in %s.", __func__);
366 }
367
368 /* Get current step */
369 /* Read CHG_CNTL_1 */
370 result = PCA9422_ReadRegs(handle, PCA9422_CHG_CNTL1, ®Val, 1U);
371 if (!result)
372 {
373 LOG_INFO("Error in I2C operation in %s.", __func__);
374 }
375 currStep = ((regVal & PCA9422_CHARGER_CNTL_1_CHG_CURRENT_STEP) != 0U) ? 50U : 25U;
376
377 /* Read CHG_CNTL_3 */
378 result = PCA9422_ReadRegs(handle, PCA9422_CHG_CNTL3, ®Val, 1U);
379 if (!result)
380 {
381 LOG_INFO("Error in I2C operation in %s.", __func__);
382 }
383 iFastReg = (uint16_t)regVal * currStep + (uint16_t)currStep;
384
385 /* Write CHARGER_LOCK bit */
386 regVal = PCA9422_CHARGER_LOCK_LOCK;
387 result = PCA9422_WriteRegs(handle, PCA9422_CHG_CNTL0, ®Val, 1U);
388 if (!result)
389 {
390 LOG_INFO("Error in I2C operation in %s\r\n", __func__);
391 }
392
393 return iFastReg;
394 }
395
PCA9422_GetChargeCurrent(pca9422_handle_t * handle)396 uint16_t PCA9422_GetChargeCurrent(pca9422_handle_t *handle)
397 {
398 uint8_t chgSts[4];
399 uint8_t regVal, regBit = 0U;
400 uint16_t iCharge;
401 uint8_t preChgCurr[2] = {10U, 20U}; /* 10%, 20% */
402 uint8_t topOffCurr[4] = {25U, 50U, 75U, 100U}; /* 2.5%, 5.0%, 7.5%, 10.0% */
403 uint8_t thermCurr[4] = {100U, 75U, 50U, 25U}; /* 1.0, 0.75, 0.5, 0.25 */
404 float tempVal;
405 bool result;
406
407 /* Read CHARGER_0_STS ~ CHARGER_3_STS */
408 result = PCA9422_ReadRegs(handle, PCA9422_CHARGER_0_STS, chgSts, 4U);
409 assert(result);
410
411 /* Write CHARGER_LOCK bit */
412 regVal = PCA9422_CHARGER_LOCK_UNLOCK;
413 result = PCA9422_WriteRegs(handle, PCA9422_CHG_CNTL0, ®Val, 1U);
414 assert(result);
415
416 /* Get fast charge current */
417 iCharge = PCA9422_GetFastChargeCurrent(handle) / 10U;
418
419 /* Check Charge state first */
420 /* Check CHARGER_0_STS */
421 if ((chgSts[0] & PCA9422_INT_CHARGER_0_CHG_QUAL_OK) != 0U)
422 {
423 /* Qualification process for charging passed */
424 /* Charging */
425 if ((chgSts[0] & PCA9422_INT_CHARGER_0_FAST_CHARGE) != 0U)
426 {
427 /* Keep iCharge */
428 }
429 else if ((chgSts[0] & PCA9422_INT_CHARGER_0_CV_MODE) != 0U)
430 {
431 /* Keep iCharge */
432 }
433 else if ((chgSts[0] & PCA9422_INT_CHARGER_0_TOPOFF) != 0U)
434 {
435 /* Read topoff current */
436 /* Read CHG_CNTL_4 */
437 result = PCA9422_ReadRegs(handle, PCA9422_CHG_CNTL4, ®Val, 1U);
438 assert(result);
439 regBit =
440 (regVal & PCA9422_CHARGER_CNTL_4_TOPOFF_CURRENT) >> MASK2SHIFT(PCA9422_CHARGER_CNTL_4_TOPOFF_CURRENT);
441 tempVal = (float)iCharge * (float)topOffCurr[regBit] / 10.0f / 100.0f;
442 iCharge = (uint16_t)tempVal;
443 }
444 else if ((chgSts[0] & PCA9422_INT_CHARGER_0_PRECHARGE) != 0U)
445 {
446 /* Read precharge current */
447 /* Read CHG_CNTL_1 */
448 result = PCA9422_ReadRegs(handle, PCA9422_CHG_CNTL1, ®Val, 1U);
449 assert(result);
450 regBit =
451 (regVal & PCA9422_CHARGER_CNTL_1_PRECHG_CURRENT) >> MASK2SHIFT(PCA9422_CHARGER_CNTL_1_PRECHG_CURRENT);
452 tempVal = (float)iCharge * (float)preChgCurr[regBit] / 100.0f;
453 iCharge = (uint16_t)tempVal;
454 }
455 else
456 {
457 /* iCharge */
458 iCharge = 0U;
459 }
460 }
461 else
462 {
463 iCharge = 0U;
464 }
465
466 /* Check whether JEITA function is enabled or not */
467 /* Read CHG_CNTL_5 */
468 result = PCA9422_ReadRegs(handle, PCA9422_CHG_CNTL5, ®Val, 1U);
469 assert(result);
470 /* Check THERM_NTC_EN bit */
471 if (((regVal & PCA9422_CHARGER_CNTL_5_THERM_NTC_EN) != 0U) && (iCharge != 0U))
472 {
473 /* Use JEITA function */
474 /* Check JEITA interrupt happens */
475 if ((chgSts[1] & PCA9422_INT_CHARGER_1_THERM_HOT) != 0U)
476 {
477 iCharge = 0U;
478 }
479 else if ((chgSts[1] & PCA9422_INT_CHARGER_1_THERM_WARM_PLUS) != 0U)
480 {
481 /* NEW_I_VBAT_AT_50C */
482 /* Read CHG_CNTL_9 */
483 result = PCA9422_ReadRegs(handle, PCA9422_CHG_CNTL9, ®Val, 1U);
484 assert(result);
485 regBit = (regVal & PCA9422_CHARGER_CNTL_9_NEW_I_VBAT_AT_50C) >>
486 MASK2SHIFT(PCA9422_CHARGER_CNTL_9_NEW_I_VBAT_AT_50C);
487 tempVal = (float)iCharge * (float)thermCurr[regBit] / 100.0f;
488 iCharge = (uint16_t)tempVal;
489 }
490 else if ((chgSts[1] & PCA9422_INT_CHARGER_1_THERM_WARM) != 0U)
491 {
492 /* NEW_I_VBAT_AT_45C */
493 /* Read CHG_CNTL_9 */
494 result = PCA9422_ReadRegs(handle, PCA9422_CHG_CNTL9, ®Val, 1U);
495 assert(result);
496 regBit = (regVal & PCA9422_CHARGER_CNTL_9_NEW_I_VBAT_AT_45C) >>
497 MASK2SHIFT(PCA9422_CHARGER_CNTL_9_NEW_I_VBAT_AT_45C);
498 tempVal = (float)iCharge * (float)thermCurr[regBit] / 100.0f;
499 iCharge = (uint16_t)tempVal;
500 }
501 else if ((chgSts[1] & PCA9422_INT_CHARGER_1_THERM_COOL) != 0U)
502 {
503 /* NEW_I_VBAT_AT_10C */
504 /* Read CHG_CNTL_7 */
505 result = PCA9422_ReadRegs(handle, PCA9422_CHG_CNTL7, ®Val, 1U);
506 assert(result);
507 regBit = (regVal & PCA9422_CHARGER_CNTL_7_NEW_I_VBAT_AT_10C) >>
508 MASK2SHIFT(PCA9422_CHARGER_CNTL_7_NEW_I_VBAT_AT_10C);
509 tempVal = (float)iCharge * (float)thermCurr[regBit] / 100.0f;
510 iCharge = (uint16_t)tempVal;
511 }
512 else if ((chgSts[1] & PCA9422_INT_CHARGER_1_THERM_COLD) != 0U)
513 {
514 iCharge = 0U;
515 }
516 else if ((chgSts[1] & PCA9422_INT_CHARGER_1_VBAT_OVP) != 0U)
517 {
518 iCharge = 0U;
519 }
520 else if ((chgSts[1] & PCA9422_INT_CHARGER_1_NO_BATTERY) != 0U)
521 {
522 iCharge = 0U;
523 }
524 else
525 {
526 /* PCA9422_INT_CHARGER_1_VBAT_OVP - Keep iCharge */
527 }
528 }
529
530 /* Write CHARGER_LOCK bit */
531 regVal = PCA9422_CHARGER_LOCK_LOCK;
532 result = PCA9422_WriteRegs(handle, PCA9422_CHG_CNTL0, ®Val, 1U);
533 assert(result);
534
535 return (result ? iCharge : 0U);
536 }
537
PCA9422_GetVBATRegulation(pca9422_handle_t * handle)538 uint16_t PCA9422_GetVBATRegulation(pca9422_handle_t *handle)
539 {
540 uint8_t chgSts[4];
541 uint8_t regVal = 0U;
542 uint8_t regBit = 0U;
543 uint16_t vFloat;
544 uint8_t newVbatOffset[4] = {0U, 100U, 150U, 200U}; /* 0, 100mV, 150mV, 200mV */
545 bool result = true;
546
547 /* Write CHARGER_LOCK bit to UNLOCK */
548 regVal = PCA9422_CHARGER_LOCK_UNLOCK;
549 result = PCA9422_WriteRegs(handle, PCA9422_CHG_CNTL0, ®Val, 1U);
550 if (result == false)
551 {
552 vFloat = 0U;
553 goto error;
554 }
555
556 /* Read CHG_CNTL_2 */
557 result = PCA9422_ReadRegs(handle, PCA9422_CHG_CNTL2, ®Val, 1U);
558 if (result == false)
559 {
560 vFloat = 0U;
561 goto error;
562 }
563 /* Convert reg value to vFloat */
564 vFloat = (uint16_t)regVal * PCA9422_VBAT_REG_STEP + PCA9422_VBAT_REG_MIN;
565
566 /* Check JEITA condition */
567 /* Read CHARGER_0_STS ~ CHARGER_3_STS */
568 result = PCA9422_ReadRegs(handle, PCA9422_CHARGER_0_STS, chgSts, 4U);
569 if (result == false)
570 {
571 vFloat = 0U;
572 goto error;
573 }
574
575 /* Check whether JEITA function is enabled or not */
576 /* Read CHG_CNTL_5 */
577 result = PCA9422_ReadRegs(handle, PCA9422_CHG_CNTL5, ®Val, 1U);
578 if (result == false)
579 {
580 vFloat = 0U;
581 goto error;
582 }
583 /* Check THERM_NTC_EN bit */
584 if ((regVal & PCA9422_CHARGER_CNTL_5_THERM_NTC_EN) != 0U)
585 {
586 /* Use JEITA function */
587 /* Check JEITA interrupt happens */
588 if ((chgSts[1] & PCA9422_INT_CHARGER_1_THERM_WARM_PLUS) != 0U)
589 {
590 /* NEW_VBAT_AT_50C */
591 /* Read CHG_CNTL_9 */
592 result = PCA9422_ReadRegs(handle, PCA9422_CHG_CNTL9, ®Val, 1U);
593 if (result == false)
594 {
595 vFloat = 0U;
596 goto error;
597 }
598 regBit =
599 (regVal & PCA9422_CHARGER_CNTL_9_NEW_VBAT_AT_50C) >> MASK2SHIFT(PCA9422_CHARGER_CNTL_9_NEW_VBAT_AT_50C);
600 vFloat = vFloat - newVbatOffset[regBit];
601 }
602 else if ((chgSts[1] & PCA9422_INT_CHARGER_1_THERM_WARM) != 0U)
603 {
604 /* NEW_VBAT_AT_45C */
605 /* Read CHG_CNTL_7 */
606 result = PCA9422_ReadRegs(handle, PCA9422_CHG_CNTL7, ®Val, 1U);
607 if (result == false)
608 {
609 vFloat = 0U;
610 goto error;
611 }
612 regBit =
613 (regVal & PCA9422_CHARGER_CNTL_7_NEW_VBAT_AT_45C) >> MASK2SHIFT(PCA9422_CHARGER_CNTL_7_NEW_VBAT_AT_45C);
614 vFloat = vFloat - newVbatOffset[regBit];
615 }
616 else
617 {
618 /* No Charge or Keep Vreg */
619 }
620 }
621
622 /* Write CHARGER_LOCK bit to LOCK */
623 regVal = PCA9422_CHARGER_LOCK_LOCK;
624 result = PCA9422_WriteRegs(handle, PCA9422_CHG_CNTL0, ®Val, 1U);
625 if (result == false)
626 {
627 vFloat = 0U;
628 }
629
630 error:
631 return vFloat;
632 }
633
PCA9422_SetVBATRegulation(pca9422_handle_t * handle,uint16_t vFloat)634 bool PCA9422_SetVBATRegulation(pca9422_handle_t *handle, uint16_t vFloat)
635 {
636 uint8_t regVal = 0U;
637 uint16_t vSys = 0U;
638 bool result = true;
639
640 /* Check maximum VFLOAT */
641 if (vFloat > PCA9422_VBAT_REG_MAX)
642 {
643 vFloat = PCA9422_VBAT_REG_MAX;
644 }
645 /* First, set new VSYS_REG */
646 vSys = vFloat + PCA9422_VBAT_CLAMP_OFFSET;
647 if (vSys < PCA9422_VSYS_REG_MIN)
648 {
649 vSys = PCA9422_VSYS_REG_MIN;
650 }
651 /* Convert vSys to reg value */
652 regVal = (uint8_t)PCA9422_VSYS_REG(vSys);
653 result = PCA9422_ModifyRegReadback(handle, PCA9422_CHGIN_CNTL_3, PCA9422_CHGIN_CNTL_3_VSYS_REG,
654 regVal << MASK2SHIFT(PCA9422_CHGIN_CNTL_3_VSYS_REG));
655 if (result == false)
656 {
657 goto error;
658 }
659
660 /* Write CHARGER_LOCK bit to UNLOCK */
661 regVal = PCA9422_CHARGER_LOCK_UNLOCK;
662 result = PCA9422_WriteRegs(handle, PCA9422_CHG_CNTL0, ®Val, 1U);
663 if (result == false)
664 {
665 goto error;
666 }
667
668 /* Convert vFloat to reg value */
669 regVal = (uint8_t)PCA9422_VBAT_REG(vFloat);
670 result = PCA9422_WriteRegsReadback(handle, PCA9422_CHG_CNTL2, ®Val);
671 if (result == false)
672 {
673 goto error;
674 }
675
676 /* Write CHARGER_LOCK bit to LOCK */
677 regVal = PCA9422_CHARGER_LOCK_LOCK;
678 result = PCA9422_WriteRegs(handle, PCA9422_CHG_CNTL0, ®Val, 1U);
679
680 error:
681 return result;
682 }
683
PCA9422_SetRechargeThreshold(pca9422_handle_t * handle,uint8_t rechgTh)684 bool PCA9422_SetRechargeThreshold(pca9422_handle_t *handle, uint8_t rechgTh)
685 {
686 uint8_t regVal;
687 bool result = true;
688
689 /* Write CHARGER_LOCK bit */
690 regVal = PCA9422_CHARGER_LOCK_UNLOCK;
691 result = PCA9422_WriteRegs(handle, PCA9422_CHG_CNTL0, ®Val, 1U);
692 if (result == false)
693 {
694 goto error;
695 }
696
697 /* Set recharge threshold */
698 regVal = rechgTh;
699 result = PCA9422_ModifyReg(handle, PCA9422_CHG_CNTL4, PCA9422_CHARGER_CNTL_4_RECHARGE_TH, regVal);
700 if (result == false)
701 {
702 goto error;
703 }
704
705 /* Write CHARGER_LOCK bit */
706 regVal = PCA9422_CHARGER_LOCK_LOCK;
707 result = PCA9422_WriteRegs(handle, PCA9422_CHG_CNTL0, ®Val, 1U);
708
709 error:
710 return result;
711 }
712
PCA9422_SetPrechargeTimer(pca9422_handle_t * handle,uint8_t tPrechg)713 bool PCA9422_SetPrechargeTimer(pca9422_handle_t *handle, uint8_t tPrechg)
714 {
715 uint8_t regVal;
716 bool result = true;
717
718 /* Write CHARGER_LOCK bit */
719 regVal = PCA9422_CHARGER_LOCK_UNLOCK;
720 result = PCA9422_WriteRegs(handle, PCA9422_CHG_CNTL0, ®Val, 1U);
721 if (result == false)
722 {
723 goto error;
724 }
725
726 /* Set precharge timer */
727 regVal = tPrechg;
728 result = PCA9422_ModifyReg(handle, PCA9422_CHG_CNTL4, PCA9422_CHARGER_CNTL_4_PRE_CHG_TIMER, regVal);
729 if (result == false)
730 {
731 goto error;
732 }
733
734 /* Write CHARGER_LOCK bit */
735 regVal = PCA9422_CHARGER_LOCK_LOCK;
736 result = PCA9422_WriteRegs(handle, PCA9422_CHG_CNTL0, ®Val, 1U);
737
738 error:
739 return result;
740 }
741
PCA9422_SetFastchargeTimer(pca9422_handle_t * handle,uint8_t tFastchg)742 bool PCA9422_SetFastchargeTimer(pca9422_handle_t *handle, uint8_t tFastchg)
743 {
744 uint8_t regVal;
745 bool result = true;
746
747 /* Write CHARGER_LOCK bit */
748 regVal = PCA9422_CHARGER_LOCK_UNLOCK;
749 result = PCA9422_WriteRegs(handle, PCA9422_CHG_CNTL0, ®Val, 1U);
750 if (result == false)
751 {
752 goto error;
753 }
754
755 /* Set fast charge timer */
756 regVal = tFastchg;
757 result = PCA9422_ModifyReg(handle, PCA9422_CHG_CNTL7, PCA9422_CHARGER_CNTL_7_FAST_CHG_TIMER, regVal);
758 if (result == false)
759 {
760 goto error;
761 }
762
763 /* Write CHARGER_LOCK bit */
764 regVal = PCA9422_CHARGER_LOCK_LOCK;
765 result = PCA9422_WriteRegs(handle, PCA9422_CHG_CNTL0, ®Val, 1U);
766
767 error:
768 return result;
769 }
770
PCA9422_SetTopoffTimer(pca9422_handle_t * handle,uint8_t tTopoff)771 bool PCA9422_SetTopoffTimer(pca9422_handle_t *handle, uint8_t tTopoff)
772 {
773 uint8_t regVal;
774 bool result = true;
775
776 /* Write CHARGER_LOCK bit */
777 regVal = PCA9422_CHARGER_LOCK_UNLOCK;
778 result = PCA9422_WriteRegs(handle, PCA9422_CHG_CNTL0, ®Val, 1U);
779 if (result == false)
780 {
781 goto error;
782 }
783
784 /* Set fast charge timer */
785 regVal = tTopoff;
786 result = PCA9422_ModifyReg(handle, PCA9422_CHG_CNTL8, PCA9422_CHARGER_CNTL_8_TOP_OFF_TIMER, regVal);
787 if (result == false)
788 {
789 goto error;
790 }
791
792 /* Write CHARGER_LOCK bit */
793 regVal = PCA9422_CHARGER_LOCK_LOCK;
794 result = PCA9422_WriteRegs(handle, PCA9422_CHG_CNTL0, ®Val, 1U);
795
796 error:
797 return result;
798 }
799
PCA9422_GetChargeState(pca9422_handle_t * handle)800 uint8_t PCA9422_GetChargeState(pca9422_handle_t *handle)
801 {
802 uint8_t chgSts = 0U;
803 uint8_t regVal[4];
804
805 /* Read CHARGER_0_STS ~ CHARGER_3_STS */
806 (void)PCA9422_ReadRegs(handle, PCA9422_CHARGER_0_STS, regVal, 4U);
807
808 /* Check CHARGER_0_STS */
809 if ((regVal[0] & PCA9422_INT_CHARGER_0_CHG_QUAL_OK) != 0U)
810 {
811 /* Qualification process for charging passed */
812 /* Charging */
813 if (((regVal[0] & PCA9422_INT_CHARGER_0_CV_MODE) != 0U) || ((regVal[0] & PCA9422_INT_CHARGER_0_TOPOFF) != 0U))
814 {
815 chgSts = 0x03U; /* CV mode - CV or TOPOFF */
816 }
817 else if (((regVal[0] & PCA9422_INT_CHARGER_0_FAST_CHARGE) != 0U) ||
818 ((regVal[0] & PCA9422_INT_CHARGER_0_PRECHARGE) != 0U))
819 {
820 chgSts = 0x01U; /* CC mode - FAST CHARGE or PRE-CHARGE */
821 }
822 else
823 {
824 chgSts = 0x00U; /* Not charging */
825 }
826
827 /* Check CHARGER_2_STS */
828 if ((regVal[2] & PCA9422_INT_CHARGER_2_CHARGE_DONE) != 0U)
829 {
830 chgSts = 0x04U;
831 }
832 }
833 else
834 {
835 /* Any charge fault condition happens or No charge */
836 chgSts = 0x00U;
837 }
838
839 return chgSts;
840 }
841
PCA9422_SelectAMUXChannel(pca9422_handle_t * handle,pca9422_amux_channel_t amuxCh)842 void PCA9422_SelectAMUXChannel(pca9422_handle_t *handle, pca9422_amux_channel_t amuxCh)
843 {
844 uint8_t regVal;
845
846 /* Write CHARGER_LOCK bit */
847 regVal = PCA9422_CHARGER_LOCK_UNLOCK;
848 (void)PCA9422_WriteRegs(handle, PCA9422_CHG_CNTL0, ®Val, 1U);
849
850 (void)PCA9422_ModifyReg(handle, PCA9422_CHG_CNTL10, PCA9422_CHARGER_CNTL_10_AMUX_CHANNEL, (uint8_t)amuxCh);
851
852 /* Write CHARGER_LOCK bit */
853 regVal = PCA9422_CHARGER_LOCK_LOCK;
854 (void)PCA9422_WriteRegs(handle, PCA9422_CHG_CNTL0, ®Val, 1U);
855 }
856
PCA9422_SetAMUXMode(pca9422_handle_t * handle,pca9422_amux_mode_t mode)857 void PCA9422_SetAMUXMode(pca9422_handle_t *handle, pca9422_amux_mode_t mode)
858 {
859 uint8_t regVal;
860 bool result = true;
861
862 /* Write CHARGER_LOCK bit */
863 regVal = PCA9422_CHARGER_LOCK_UNLOCK;
864 result = PCA9422_WriteRegs(handle, PCA9422_CHG_CNTL0, ®Val, 1U);
865 if (!result)
866 {
867 LOG_INFO("I2C operation error in %s\r\n", __func__);
868 }
869
870 result = PCA9422_ModifyReg(handle, PCA9422_CHG_CNTL10, PCA9422_CHARGER_CNTL_10_AMUX_MODE, (uint8_t)mode);
871 if (!result)
872 {
873 LOG_INFO("I2C operation error in %s\r\n", __func__);
874 }
875
876 /* Write CHARGER_LOCK bit */
877 regVal = PCA9422_CHARGER_LOCK_LOCK;
878 result = PCA9422_WriteRegs(handle, PCA9422_CHG_CNTL0, ®Val, 1U);
879 if (!result)
880 {
881 LOG_INFO("I2C operation error in %s\r\n", __func__);
882 }
883 }
884
PCA9422_GetAMUXMode(pca9422_handle_t * handle)885 pca9422_amux_mode_t PCA9422_GetAMUXMode(pca9422_handle_t *handle)
886 {
887 bool result;
888 uint8_t regVal;
889
890 /* Write CHARGER_LOCK bit */
891 regVal = PCA9422_CHARGER_LOCK_UNLOCK;
892 result = PCA9422_WriteRegs(handle, PCA9422_CHG_CNTL0, ®Val, 1U);
893 if (!result)
894 {
895 assert(false);
896 }
897
898 result = PCA9422_ReadRegs(handle, PCA9422_CHG_CNTL10, ®Val, 1U);
899 if (!result)
900 {
901 assert(false);
902 }
903
904 /* Write CHARGER_LOCK bit */
905 regVal = PCA9422_CHARGER_LOCK_LOCK;
906 result = PCA9422_WriteRegs(handle, PCA9422_CHG_CNTL0, ®Val, 1U);
907
908 if (!result)
909 {
910 assert(false);
911 }
912
913 regVal = regVal & PCA9422_CHARGER_CNTL_10_AMUX_MODE;
914 return (pca9422_amux_mode_t)regVal;
915 }
916
PCA9422_SetAMUXConfig(pca9422_handle_t * handle,pca9422_amux_config_t config)917 bool PCA9422_SetAMUXConfig(pca9422_handle_t *handle, pca9422_amux_config_t config)
918 {
919 bool result;
920 uint8_t regVal;
921
922 /* Write CHARGER_LOCK bit */
923 regVal = PCA9422_CHARGER_LOCK_UNLOCK;
924 result = PCA9422_WriteRegs(handle, PCA9422_CHG_CNTL0, ®Val, 1U);
925 if (!result)
926 {
927 return result;
928 }
929
930 regVal = (uint8_t)(config.waitTime | config.amuxMode | config.vbatGain | config.thermGain | config.amuxChannel);
931 result = PCA9422_WriteRegs(handle, PCA9422_CHG_CNTL10, ®Val, 1U);
932 if (!result)
933 {
934 return result;
935 }
936
937 /* Write CHARGER_LOCK bit */
938 regVal = PCA9422_CHARGER_LOCK_LOCK;
939 result = PCA9422_WriteRegs(handle, PCA9422_CHG_CNTL0, ®Val, 1U);
940
941 return result;
942 }
943
PCA9422_GetAMUXScaleFactor(pca9422_handle_t * handle,pca9422_amux_channel_t channel)944 float PCA9422_GetAMUXScaleFactor(pca9422_handle_t *handle, pca9422_amux_channel_t channel)
945 {
946 float scaleFactor;
947 uint8_t regVal;
948
949 switch (channel)
950 {
951 case kPCA9422_AMUXChannel_Off:
952 scaleFactor = 0.0f;
953 break;
954 case kPCA9422_AMUXChannel_Vbat:
955 case kPCA9422_AMUXChannel_Vsys:
956 /* Get scale factor */
957 (void)PCA9422_ReadRegs(handle, PCA9422_CHG_CNTL10, ®Val, 1U);
958 scaleFactor = ((regVal & PCA9422_CHARGER_CNTL_10_AMUX_VBAT_VSYS_GAIN) != 0U) ? 4.0f : 3.0f;
959 break;
960 case kPCA9422_AMUXChannel_Therm:
961 case kPCA9422_AMUXChannel_ThermBias:
962 /* Get scale factor */
963 (void)PCA9422_ReadRegs(handle, PCA9422_CHG_CNTL10, ®Val, 1U);
964 scaleFactor = ((regVal & PCA9422_CHARGER_CNTL_10_AMUX_THERM_GAIN) != 0U) ? 1.5f : 1.0f;
965 break;
966 case kPCA9422_AMUXChannel_Vin:
967 scaleFactor = 4.0f;
968 break;
969 default:
970 scaleFactor = 0.0f;
971 break;
972 }
973 return scaleFactor;
974 }
975
PCA9422_SetEnableCharge(pca9422_handle_t * handle,bool enable)976 bool PCA9422_SetEnableCharge(pca9422_handle_t *handle, bool enable)
977 {
978 uint8_t regVal = 0U;
979 bool result;
980
981 /* Write CHARGER_LOCK bit to UNLOCK */
982 regVal = PCA9422_CHARGER_LOCK_UNLOCK;
983 result = PCA9422_WriteRegs(handle, PCA9422_CHG_CNTL0, ®Val, 1U);
984 if (result == false)
985 {
986 goto error;
987 }
988
989 if (enable == true)
990 {
991 /* Read USB_SUSPEND bit first */
992 result = PCA9422_ReadRegs(handle, PCA9422_CHG_CNTL9, ®Val, 1U);
993 if (result && ((regVal & PCA9422_CHARGER_CNTL_9_USB_SUSPEND) != 0U))
994 {
995 /* Disable suspend Mode first */
996 regVal = 0U;
997 result = PCA9422_ModifyRegReadback(handle, PCA9422_CHG_CNTL9, PCA9422_CHARGER_CNTL_9_USB_SUSPEND, regVal);
998 if (result == false)
999 {
1000 goto error;
1001 }
1002 }
1003 }
1004
1005 regVal = (enable == true) ? PCA9422_CHARGER_CNTL_1_CHARGER_EN : 0U;
1006 result = PCA9422_ModifyRegReadback(handle, PCA9422_CHG_CNTL1, PCA9422_CHARGER_CNTL_1_CHARGER_EN, regVal);
1007 if (result == false)
1008 {
1009 goto error;
1010 }
1011
1012 /* Write CHARGER_LOCK bit to LOCK */
1013 regVal = PCA9422_CHARGER_LOCK_LOCK;
1014 result = PCA9422_WriteRegs(handle, PCA9422_CHG_CNTL0, ®Val, 1U);
1015
1016 error:
1017 return result;
1018 }
1019
PCA9422_SetUSBSuspendMode(pca9422_handle_t * handle,bool enable)1020 bool PCA9422_SetUSBSuspendMode(pca9422_handle_t *handle, bool enable)
1021 {
1022 uint8_t regVal = 0U;
1023 bool result;
1024
1025 /* Write CHARGER_LOCK bit to UNLOCK */
1026 regVal = PCA9422_CHARGER_LOCK_UNLOCK;
1027 result = PCA9422_WriteRegs(handle, PCA9422_CHG_CNTL0, ®Val, 1U);
1028 if (result == false)
1029 {
1030 goto error;
1031 }
1032
1033 regVal = (enable == true) ? PCA9422_CHARGER_CNTL_9_USB_SUSPEND : 0U;
1034 result = PCA9422_ModifyRegReadback(handle, PCA9422_CHG_CNTL9, PCA9422_CHARGER_CNTL_9_USB_SUSPEND, regVal);
1035 if (result == false)
1036 {
1037 goto error;
1038 }
1039
1040 /* Write CHARGER_LOCK bit to LOCK */
1041 regVal = PCA9422_CHARGER_LOCK_LOCK;
1042 result = PCA9422_WriteRegs(handle, PCA9422_CHG_CNTL0, ®Val, 1U);
1043
1044 error:
1045 return result;
1046 }
1047
1048 /*!
1049 * @name Regulator Functions
1050 * @{
1051 */
PCA9422_GetDefaultBuckConfig(pca9422_buck_config_t * buckCfg)1052 void PCA9422_GetDefaultBuckConfig(pca9422_buck_config_t *buckCfg)
1053 {
1054 /* Buck1/2/3 default configuration */
1055 /* BUCK1 default configuration */
1056 buckCfg[0].dvsUpStep = 0U; /* 6.25mV */
1057 buckCfg[0].dvsDnStep = 0U; /* 6.25mV */
1058 buckCfg[0].dvsCtrl = (uint8_t)kPCA9422_DVS0thrI2CInActiveAndSleep;
1059 buckCfg[0].rampSpeed = kPCA9422_BxRamp_25mVp2us;
1060 buckCfg[0].lpMode = kPCA9422_BxLPmodeNormal;
1061 buckCfg[0].activeDischg = kPCA9422_BxADEnabled;
1062 buckCfg[0].fpwmEn = kPCA9422_BxAutoPFMandPWM;
1063 buckCfg[0].enMode = kPCA9422_EnmodeOnAll;
1064 buckCfg[0].dvsVout[0] = 1000000U; /* 1.0V */
1065 buckCfg[0].dvsVout[1] = 1000000U; /* 1.0V */
1066 buckCfg[0].dvsVout[2] = 1000000U; /* 1.0V */
1067 buckCfg[0].dvsVout[3] = 1000000U; /* 1.0V */
1068 buckCfg[0].dvsVout[4] = 1000000U; /* 1.0V */
1069 buckCfg[0].dvsVout[5] = 1000000U; /* 1.0V */
1070 buckCfg[0].dvsVout[6] = 1000000U; /* 1.0V */
1071 buckCfg[0].dvsVout[7] = 1000000U; /* 1.0V */
1072 buckCfg[0].stbyVout = 1000000U; /* 1.0V */
1073 buckCfg[0].maxVout = 1200000U; /* 1.2V */
1074 buckCfg[0].sleepVout = 400000U; /* 0.4V */
1075
1076 /* BUCK2 default configuration */
1077 buckCfg[1].dvsUpStep = 0U; /* 25mV */
1078 buckCfg[1].dvsDnStep = 0U; /* 25mV */
1079 buckCfg[1].dvsCtrl = (uint8_t)kPCA9422_DVS0thrI2CInActiveAndSleep;
1080 buckCfg[1].rampSpeed = kPCA9422_BxRamp_25mVp2us;
1081 buckCfg[1].lpMode = kPCA9422_BxLPmodeNormal;
1082 buckCfg[1].activeDischg = kPCA9422_BxADEnabled;
1083 buckCfg[1].fpwmEn = kPCA9422_BxAutoPFMandPWM;
1084 buckCfg[1].enMode = kPCA9422_EnmodeOnAll;
1085 buckCfg[1].dvsVout[0] = 1100000U; /* 1.1V */
1086 buckCfg[1].dvsVout[1] = 1000000U; /* 1.0V */
1087 buckCfg[1].dvsVout[2] = 1000000U; /* 1.0V */
1088 buckCfg[1].dvsVout[3] = 1000000U; /* 1.0V */
1089 buckCfg[1].dvsVout[4] = 1000000U; /* 1.0V */
1090 buckCfg[1].dvsVout[5] = 1000000U; /* 1.0V */
1091 buckCfg[1].dvsVout[6] = 1000000U; /* 1.0V */
1092 buckCfg[1].dvsVout[7] = 1000000U; /* 1.0V */
1093 buckCfg[1].stbyVout = 1000000U; /* 1.0V */
1094 buckCfg[1].maxVout = 1400000U; /* 1.4V */
1095 buckCfg[1].sleepVout = 400000U; /* 0.4V */
1096
1097 /* BUCK3 default configuration */
1098 buckCfg[2].dvsUpStep = 0U; /* 25mV */
1099 buckCfg[2].dvsDnStep = 0U; /* 25mV */
1100 buckCfg[2].dvsCtrl = (uint8_t)kPCA9422_DVS0thrI2CInActiveAndSleep;
1101 buckCfg[2].rampSpeed = kPCA9422_BxRamp_25mVp2us;
1102 buckCfg[2].lpMode = kPCA9422_BxLPmodeNormal;
1103 buckCfg[2].activeDischg = kPCA9422_BxADEnabled;
1104 buckCfg[2].fpwmEn = kPCA9422_BxAutoPFMandPWM;
1105 buckCfg[2].enMode = kPCA9422_EnmodeOnAll;
1106 buckCfg[2].dvsVout[0] = 1000000U; /* 1.0V */
1107 buckCfg[2].dvsVout[1] = 1000000U; /* 1.0V */
1108 buckCfg[2].dvsVout[2] = 1000000U; /* 1.0V */
1109 buckCfg[2].dvsVout[3] = 1000000U; /* 1.0V */
1110 buckCfg[2].dvsVout[4] = 1000000U; /* 1.0V */
1111 buckCfg[2].dvsVout[5] = 1000000U; /* 1.0V */
1112 buckCfg[2].dvsVout[6] = 1000000U; /* 1.0V */
1113 buckCfg[2].dvsVout[7] = 1000000U; /* 1.0V */
1114 buckCfg[2].stbyVout = 1000000U; /* 1.0V */
1115 buckCfg[2].maxVout = 1200000U; /* 1.2V */
1116 buckCfg[2].sleepVout = 400000U; /* 0.4V */
1117 }
1118
PCA9422_GetDefaultLDO234Config(pca9422_ldo234_config_t * ldoCfg)1119 void PCA9422_GetDefaultLDO234Config(pca9422_ldo234_config_t *ldoCfg)
1120 {
1121 /* LDO2/3/4 default configuration */
1122 /* LDO2 default configuration */
1123 ldoCfg[0].cSel = kPCA9422_LDO23AutoCoutDetection;
1124 ldoCfg[0].llSel = kPCA9422_LDO23LLSel15mOhm;
1125 ldoCfg[0].lpMode = kPCA9422_LDO23LPmodeNormal;
1126 ldoCfg[0].enMode = kPCA9422_EnmodeOnAll;
1127 ldoCfg[0].ldoMode = kPCA9422_LDO23LDOMode;
1128 ldoCfg[0].activeDischg = true;
1129 ldoCfg[0].vout = 1800000U; /* 1.8V */
1130 ldoCfg[0].stbyVout = 1800000U; /* 1.8V */
1131 ldoCfg[0].sleepVout = 1800000U; /* 1.8V */
1132
1133 /* LDO3 default configuration */
1134 ldoCfg[1].cSel = kPCA9422_LDO23AutoCoutDetection;
1135 ldoCfg[1].llSel = kPCA9422_LDO23LLSel15mOhm;
1136 ldoCfg[1].lpMode = kPCA9422_LDO23LPmodeNormal;
1137 ldoCfg[1].enMode = kPCA9422_EnmodeOnAll;
1138 ldoCfg[1].ldoMode = kPCA9422_LDO23LDOMode;
1139 ldoCfg[1].activeDischg = true;
1140 ldoCfg[1].vout = 1200000U; /* 1.2V */
1141 ldoCfg[1].stbyVout = 1200000U; /* 1.2V */
1142 ldoCfg[1].sleepVout = 1200000U; /* 1.2V */
1143
1144 /* LDO4 default configuration */
1145 ldoCfg[2].activeDischg = true;
1146 ldoCfg[2].enMode = kPCA9422_EnmodeOnAll;
1147 ldoCfg[2].vout = 3300000U; /* 3.3V */
1148 ldoCfg[2].stbyVout = 3300000U; /* 3.3V */
1149 ldoCfg[2].sleepVout = 3000000U; /* 3.0V */
1150 }
1151
PCA9422_GetDefaultLDO1Config(pca9422_ldo1_config_t * ldo1Cfg)1152 void PCA9422_GetDefaultLDO1Config(pca9422_ldo1_config_t *ldo1Cfg)
1153 {
1154 /* LDO1 default configuration */
1155 ldo1Cfg->activeDischg = true;
1156 ldo1Cfg->enMode = true; /* Always ON */
1157 ldo1Cfg->vout = 1800000U; /* 1.8V */
1158 }
1159
PCA9422_GetDefaultBBConfig(pca9422_bb_config_t * bbCfg)1160 void PCA9422_GetDefaultBBConfig(pca9422_bb_config_t *bbCfg)
1161 {
1162 bbCfg->fpwmEn = kPCA9422_BBAutoPFMandPWM;
1163 bbCfg->ocCtrl = kPCA9422_BBNotTurnOff;
1164 bbCfg->softStdn = kPCA9422_BBRampDownDisabled;
1165 bbCfg->passiveDis = kPCA9422_BBPassiveDsgEnabled;
1166 bbCfg->enInRun = kPCA9422_BBOnInRunState;
1167 bbCfg->bbMode = kPCA9422_BBOPmodeAuto;
1168 bbCfg->enMode = kPCA9422_BBEnmodeOnAll;
1169 bbCfg->lpMode = kPCA9422_BBLPmodeNormal;
1170
1171 bbCfg->vout = 1800000U; /* 1.8V */
1172 bbCfg->stdyVout = 1800000U; /* 1.8V */
1173 bbCfg->maxVout = 5000000U; /* 5.0V */
1174 bbCfg->minVout = 1800000U; /* 1.8V */
1175 bbCfg->sleepVout = 1800000U; /* 1.8V */
1176 }
1177
PCA9422_GetRegulatorDefaultConfig(pca9422_regulator_config_t * RegConfig)1178 void PCA9422_GetRegulatorDefaultConfig(pca9422_regulator_config_t *RegConfig)
1179 {
1180 pca9422_buck_config_t buck[3]; /* buck1/2/3 */
1181 pca9422_ldo234_config_t ldo[3]; /* ldo2/3/4 */
1182 pca9422_ldo1_config_t ldo1; /* ldo1 */
1183 pca9422_bb_config_t buckBoost; /* buck-boost */
1184
1185 /* Buck1/2/3 default configuration */
1186 PCA9422_GetDefaultBuckConfig(buck);
1187
1188 /* LDO2/3/4 default configuration */
1189 PCA9422_GetDefaultLDO234Config(ldo);
1190
1191 /* LDO1 default configuration */
1192 PCA9422_GetDefaultLDO1Config(&ldo1);
1193
1194 /* Buck-Boost default configuration */
1195 PCA9422_GetDefaultBBConfig(&buckBoost);
1196
1197 RegConfig->I2C_SendFunc = NULL;
1198 RegConfig->I2C_ReceiveFunc = NULL;
1199 RegConfig->standbyCtrl = kPCA9422_StandbyCtrlPins;
1200 RegConfig->standbyCfg = kPCA9422_StandbyCfgStandby;
1201 RegConfig->dvsCtrl2En = kPCA9422_DVSCtrl2PinIgnore;
1202 RegConfig->vsysUvlo = kPCA9422_VsysUVLOSel2p7V;
1203 RegConfig->smartMode = kPCA9422_SmartModeDisabled;
1204 RegConfig->buck[0] = buck[0];
1205 RegConfig->buck[1] = buck[1];
1206 RegConfig->buck[2] = buck[2];
1207 RegConfig->ldo[0] = ldo[0];
1208 RegConfig->ldo[1] = ldo[1];
1209 RegConfig->ldo[2] = ldo[2];
1210 RegConfig->ldo1 = ldo1;
1211 RegConfig->buckBoost = buckBoost;
1212 RegConfig->slaveAddress = PCA9422_DEFAULT_I2C_ADDR;
1213 }
1214
PCA9422_InitRegulator(pca9422_handle_t * handle,const pca9422_regulator_config_t * config)1215 void PCA9422_InitRegulator(pca9422_handle_t *handle, const pca9422_regulator_config_t *config)
1216 {
1217 uint8_t regVal, regAddr;
1218 uint8_t bxDVS[8];
1219 bool result;
1220 uint32_t i;
1221
1222 assert(handle);
1223 assert(config);
1224
1225 /* Initialize Callback functions. */
1226 handle->I2C_SendFunc = config->I2C_SendFunc;
1227 handle->I2C_ReceiveFunc = config->I2C_ReceiveFunc;
1228 /* Set Slave Address. */
1229 handle->slaveAddress = config->slaveAddress;
1230
1231 /* INT1_MASK */
1232 regVal = 0xFFU;
1233 regAddr = PCA9422_INT1_MASK;
1234 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
1235 if (result == false)
1236 {
1237 goto out;
1238 }
1239 /* RESET_CTRL */
1240 regVal = 0x00U;
1241 regAddr = PCA9422_RESET_CTRL;
1242 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
1243 if (result == false)
1244 {
1245 goto out;
1246 }
1247 /* PWR_SEQ_CTRL */
1248 regVal = 0x06U;
1249 regAddr = PCA9422_PWR_SEQ_CTRL;
1250 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
1251 if (result == false)
1252 {
1253 goto out;
1254 }
1255 /* SYS_CFG1 */
1256 regVal = (uint8_t)config->standbyCtrl | (uint8_t)config->standbyCfg | (uint8_t)config->dvsCtrl2En;
1257 regAddr = PCA9422_SYS_CFG1;
1258 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
1259 if (result == false)
1260 {
1261 goto out;
1262 }
1263 /* SYS_CFG2 */
1264 regVal = (uint8_t)kPCA9422_PowerSaveNormal | (uint8_t)kPCA9422_GPIOPullupLDO1 | (uint8_t)config->vsysUvlo;
1265 regAddr = PCA9422_SYS_CFG2;
1266 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
1267 if (result == false)
1268 {
1269 goto out;
1270 }
1271 /* BUCK123_DVS_CFG1 */
1272 regVal =
1273 (uint8_t)((config->buck[0].dvsUpStep << 7U) | (config->buck[0].dvsDnStep << 6U) |
1274 (config->buck[1].dvsUpStep << 5U) | (config->buck[1].dvsDnStep << 4U) | (uint8_t)(config->smartMode));
1275 regAddr = PCA9422_BUCK123_DVS_CFG1;
1276 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
1277 if (result == false)
1278 {
1279 goto out;
1280 }
1281 /* BUCK123_DVS_CFG2 */
1282 regVal =
1283 (uint8_t)((config->buck[0].dvsCtrl << 6U) | (config->buck[1].dvsCtrl << 4U) | (config->buck[2].dvsCtrl << 2U) |
1284 (config->buck[2].dvsUpStep << 1U) | (config->buck[2].dvsDnStep << 0U));
1285 regAddr = PCA9422_BUCK123_DVS_CFG2;
1286 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
1287 if (result == false)
1288 {
1289 goto out;
1290 }
1291 /* BUCK1CTRL */
1292 regVal = (uint8_t)(config->buck[0].rampSpeed) | (uint8_t)(config->buck[0].lpMode) |
1293 (uint8_t)(config->buck[0].activeDischg) | (uint8_t)(config->buck[0].fpwmEn) |
1294 (uint8_t)(config->buck[0].enMode);
1295 regAddr = PCA9422_BUCK1CTRL;
1296 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
1297 if (result == false)
1298 {
1299 goto out;
1300 }
1301 /* BUCK2CTRL */
1302 regVal = (uint8_t)(config->buck[1].rampSpeed) | (uint8_t)(config->buck[1].lpMode) |
1303 (uint8_t)(config->buck[1].activeDischg) | (uint8_t)(config->buck[1].fpwmEn) |
1304 (uint8_t)(config->buck[1].enMode);
1305 regAddr = PCA9422_BUCK2CTRL;
1306 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
1307 if (result == false)
1308 {
1309 goto out;
1310 }
1311 /* BUCK3CTRL */
1312 regVal = (uint8_t)(config->buck[2].rampSpeed) | (uint8_t)(config->buck[2].lpMode) |
1313 (uint8_t)(config->buck[2].activeDischg) | (uint8_t)(uint8_t)(config->buck[2].fpwmEn) |
1314 (uint8_t)(config->buck[2].enMode);
1315 regAddr = PCA9422_BUCK3CTRL;
1316 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
1317 if (result == false)
1318 {
1319 goto out;
1320 }
1321 /* BUCK1OUT_DVS */
1322 for (i = 0U; i < 8U; i++)
1323 {
1324 bxDVS[i] = (uint8_t)PCA9422_BUCK1_OUT_VAL(config->buck[0].dvsVout[i]);
1325 }
1326 regAddr = PCA9422_BUCK1OUT_DVS0;
1327 result = PCA9422_WriteRegs(handle, regAddr, bxDVS, 8U);
1328 if (result == false)
1329 {
1330 goto out;
1331 }
1332 /* BUCK2OUT_DVS */
1333 for (i = 0U; i < 8U; i++)
1334 {
1335 bxDVS[i] = (uint8_t)PCA9422_BUCK2_OUT_VAL(config->buck[1].dvsVout[i]);
1336 }
1337 regAddr = PCA9422_BUCK2OUT_DVS0;
1338 result = PCA9422_WriteRegs(handle, regAddr, bxDVS, 8U);
1339 if (result == false)
1340 {
1341 goto out;
1342 }
1343 /* BUCK3OUT_DVS */
1344 for (i = 0U; i < 8U; i++)
1345 {
1346 bxDVS[i] = (uint8_t)PCA9422_BUCK3_OUT_VAL(config->buck[2].dvsVout[i]);
1347 }
1348 regAddr = PCA9422_BUCK3OUT_DVS0;
1349 result = PCA9422_WriteRegs(handle, regAddr, bxDVS, 8U);
1350 if (result == false)
1351 {
1352 goto out;
1353 }
1354 /* REG_LOCK - UNLOCK KEY */
1355 regVal = (uint8_t)kPCA9422_RegLockUnlockKey;
1356 regAddr = PCA9422_REG_LOCK;
1357 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
1358 if (result == false)
1359 {
1360 goto out;
1361 }
1362 /* BUCK1OUT_STBY */
1363 regVal = (uint8_t)PCA9422_BUCK1_OUT_VAL(config->buck[0].stbyVout);
1364 regAddr = PCA9422_BUCK1OUT_STBY;
1365 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
1366 if (result == false)
1367 {
1368 goto out;
1369 }
1370 /* PCA9422_BUCK1OUT_MAX_LIMIT */
1371 regVal = (uint8_t)PCA9422_BUCK1_OUT_VAL(config->buck[0].maxVout);
1372 regAddr = PCA9422_BUCK1OUT_MAX_LIMIT;
1373 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
1374 if (result == false)
1375 {
1376 goto out;
1377 }
1378 /* BUCK1OUT_SLEEP */
1379 regVal = (uint8_t)PCA9422_BUCK1_OUT_VAL(config->buck[0].sleepVout);
1380 regAddr = PCA9422_BUCK1OUT_SLEEP;
1381 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
1382 if (result == false)
1383 {
1384 goto out;
1385 }
1386 /* BUCK2OUT_STBY */
1387 regVal = (uint8_t)PCA9422_BUCK2_OUT_VAL(config->buck[1].stbyVout);
1388 regAddr = PCA9422_BUCK2OUT_STBY;
1389 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
1390 if (result == false)
1391 {
1392 goto out;
1393 }
1394 /* BUCK2OUT_MAX_LIMIT */
1395 regVal = (uint8_t)PCA9422_BUCK2_OUT_VAL(config->buck[1].maxVout);
1396 regAddr = PCA9422_BUCK2OUT_MAX_LIMIT;
1397 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
1398 if (result == false)
1399 {
1400 goto out;
1401 }
1402 /* BUCK2OUT_SLEEP */
1403 regVal = (uint8_t)PCA9422_BUCK2_OUT_VAL(config->buck[1].sleepVout);
1404 regAddr = PCA9422_BUCK2OUT_SLEEP;
1405 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
1406 if (result == false)
1407 {
1408 goto out;
1409 }
1410 /* BUCK3OUT_STBY */
1411 regVal = (uint8_t)PCA9422_BUCK3_OUT_VAL(config->buck[2].stbyVout);
1412 regAddr = PCA9422_BUCK3OUT_STBY;
1413 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
1414 if (result == false)
1415 {
1416 goto out;
1417 }
1418 /* BUCK3OUT_MAX_LIMIT */
1419 regVal = (uint8_t)PCA9422_BUCK3_OUT_VAL(config->buck[2].maxVout);
1420 regAddr = PCA9422_BUCK3OUT_MAX_LIMIT;
1421 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
1422 if (result == false)
1423 {
1424 goto out;
1425 }
1426 /* BUCK3OUT_SLEEP */
1427 regVal = (uint8_t)PCA9422_BUCK3_OUT_VAL(config->buck[2].sleepVout);
1428 regAddr = PCA9422_BUCK3OUT_SLEEP;
1429 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
1430 if (result == false)
1431 {
1432 goto out;
1433 }
1434 /* LDO2_CFG */
1435 regVal = (uint8_t)config->ldo[0].cSel | (uint8_t)config->ldo[0].llSel | (uint8_t)config->ldo[0].lpMode |
1436 (uint8_t)config->ldo[0].enMode;
1437 regAddr = PCA9422_LDO2_CFG;
1438 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
1439 if (result == false)
1440 {
1441 goto out;
1442 }
1443 /* LDO2_OUT */
1444 regVal =((uint8_t)config->ldo[0].activeDischg << 7U) | (uint8_t)PCA9422_LDO23_OUT_VAL(config->ldo[0].vout);
1445 regAddr = PCA9422_LDO2_OUT;
1446 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
1447 if (result == false)
1448 {
1449 goto out;
1450 }
1451 /* LDO2_OUT_STBY */
1452 regVal = (uint8_t)PCA9422_LDO23_OUT_VAL(config->ldo[0].stbyVout);
1453 regAddr = PCA9422_LDO2_OUT_STBY;
1454 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
1455 if (result == false)
1456 {
1457 goto out;
1458 }
1459 /* LDO2_OUT_SLEEP */
1460 regVal = (uint8_t)PCA9422_LDO23_OUT_VAL(config->ldo[0].sleepVout);
1461 regAddr = PCA9422_LDO2_OUT_SLEEP;
1462 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
1463 if (result == false)
1464 {
1465 goto out;
1466 }
1467 /* LDO3_CFG */
1468 regVal = (uint8_t)config->ldo[1].cSel | (uint8_t)config->ldo[1].llSel | (uint8_t)config->ldo[1].lpMode |
1469 (uint8_t)config->ldo[1].enMode;
1470 regAddr = PCA9422_LDO3_CFG;
1471 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
1472 if (result == false)
1473 {
1474 goto out;
1475 }
1476 /* LDO3_OUT */
1477 regVal = (uint8_t)(((uint32_t)config->ldo[1].activeDischg << 7UL) | PCA9422_LDO23_OUT_VAL(config->ldo[1].vout));
1478 regAddr = PCA9422_LDO3_OUT;
1479 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
1480 if (result == false)
1481 {
1482 goto out;
1483 }
1484 /* LDO3_OUT_STBY */
1485 regVal = (uint8_t)PCA9422_LDO23_OUT_VAL(config->ldo[1].stbyVout);
1486 regAddr = PCA9422_LDO3_OUT_STBY;
1487 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
1488 if (result == false)
1489 {
1490 goto out;
1491 }
1492 /* LDO3_OUT_SLEEP */
1493 regVal = (uint8_t)PCA9422_LDO23_OUT_VAL(config->ldo[1].sleepVout);
1494 regAddr = PCA9422_LDO3_OUT_SLEEP;
1495 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
1496 if (result == false)
1497 {
1498 goto out;
1499 }
1500 /* LDO23_CFG */
1501 regVal = ((uint8_t)(config->ldo[0].ldoMode) << 6U) | ((uint8_t)(config->ldo[1].ldoMode) << 7U);
1502 regAddr = PCA9422_LDO23_CFG;
1503 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
1504 if (result == false)
1505 {
1506 goto out;
1507 }
1508 /* LDO4_CFG */
1509 regVal = ((uint8_t)config->ldo[2].activeDischg << 4U) | ((uint8_t)(config->ldo[2].enMode));
1510 regAddr = PCA9422_LDO4_CFG;
1511 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
1512 if (result == false)
1513 {
1514 goto out;
1515 }
1516 /* LDO4_OUT */
1517 regVal = (uint8_t)PCA9422_LDO4_OUT_VAL(config->ldo[2].vout);
1518 regAddr = PCA9422_LDO4_OUT;
1519 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
1520 if (result == false)
1521 {
1522 goto out;
1523 }
1524 /* LDO4_OUT_STBY */
1525 regVal = (uint8_t)PCA9422_LDO4_OUT_VAL(config->ldo[2].stbyVout);
1526 regAddr = PCA9422_LDO4_OUT_STBY;
1527 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
1528 if (result == false)
1529 {
1530 goto out;
1531 }
1532 /* LDO4_OUT_SLEEP */
1533 regVal = (uint8_t)PCA9422_LDO4_OUT_VAL(config->ldo[2].sleepVout);
1534 regAddr = PCA9422_LDO4_OUT_SLEEP;
1535 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
1536 if (result == false)
1537 {
1538 goto out;
1539 }
1540 /* LDO1_CFG1 */
1541 regVal = (uint8_t)(((uint32_t)config->ldo1.activeDischg << 7UL) | PCA9422_LDO1_OUT_VAL(config->ldo1.vout));
1542 regAddr = PCA9422_LDO1_CFG1;
1543 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
1544 if (result == false)
1545 {
1546 goto out;
1547 }
1548 /* LDO1_CFG2 */
1549 regVal = (uint8_t)config->ldo1.enMode;
1550 regAddr = PCA9422_LDO1_CFG2;
1551 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
1552 if (result == false)
1553 {
1554 goto out;
1555 }
1556 /* SW4_BB_CFG1 */
1557 regVal = (uint8_t)config->buckBoost.fpwmEn | (uint8_t)config->buckBoost.ocCtrl |
1558 (uint8_t)config->buckBoost.softStdn | (uint8_t)config->buckBoost.passiveDis;
1559 regAddr = PCA9422_SW4_BB_CFG1;
1560 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
1561 if (result == false)
1562 {
1563 goto out;
1564 }
1565 /* SW4_BB_CFG2 */
1566 regVal = (uint8_t)config->buckBoost.enInRun | (uint8_t)config->buckBoost.bbMode |
1567 (uint8_t)config->buckBoost.enMode | (uint8_t)config->buckBoost.lpMode;
1568 regAddr = PCA9422_SW4_BB_CFG2;
1569 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
1570 if (result == false)
1571 {
1572 goto out;
1573 }
1574 /* SW4_BB_CFG3 - BB_VOUT */
1575 regVal = (uint8_t)PCA9422_BB_OUT_VAL(config->buckBoost.vout);
1576 regAddr = PCA9422_SW4_BB_CFG3;
1577 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
1578 if (result == false)
1579 {
1580 goto out;
1581 }
1582 /* SW4_BB_CFG4 - BB_VOUT_STBY */
1583 regVal = (uint8_t)PCA9422_BB_OUT_VAL(config->buckBoost.stdyVout);
1584 regAddr = PCA9422_SW4_BB_CFG4;
1585 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
1586 if (result == false)
1587 {
1588 goto out;
1589 }
1590 /* SW4_BB_MAX_LIMIT */
1591 regVal = (uint8_t)PCA9422_BB_OUT_VAL(config->buckBoost.maxVout);
1592 regAddr = PCA9422_SW4_BB_MAX_LIMIT;
1593 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
1594 if (result == false)
1595 {
1596 goto out;
1597 }
1598 /* SW4_BB_MIN_LIMIT */
1599 regVal = (uint8_t)PCA9422_BB_OUT_VAL(config->buckBoost.minVout);
1600 regAddr = PCA9422_SW4_BB_MIN_LIMIT;
1601 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
1602 if (result == false)
1603 {
1604 goto out;
1605 }
1606 /* SW4_BB_VOUT_SLEEP */
1607 regVal = (uint8_t)PCA9422_BB_OUT_VAL(config->buckBoost.sleepVout);
1608 regAddr = PCA9422_SW4_BB_VOUT_SLEEP;
1609 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
1610 if (result == false)
1611 {
1612 goto out;
1613 }
1614 /* REG_LOCK - LOCK KEY */
1615 regVal = (uint8_t)kPCA9422_RegLockLockKey;
1616 regAddr = PCA9422_REG_LOCK;
1617 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
1618 if (result == false)
1619 {
1620 goto out;
1621 }
1622 return;
1623
1624 out:
1625 LOG_INFO("Error I2C data write[0x%2X]\r\n", regAddr);
1626 return;
1627 }
1628
PCA9422_GetDefaultPowerModeConfig(pca9422_modecfg_t * config)1629 void PCA9422_GetDefaultPowerModeConfig(pca9422_modecfg_t *config)
1630 {
1631 /* SW1 output set to 1.0V. */
1632 config->sw1OutVolt = 1000000U;
1633 /* SW2 output set to 1.1V. */
1634 config->sw2OutVolt = 1100000U;
1635 /* SW3 output set to 1.0V. */
1636 config->sw3OutVolt = 1000000U;
1637 /* SW4 output set to 1.8V. */
1638 config->sw4OutVolt = 1800000U;
1639 /* LDO1 output set to 1.8V. */
1640 config->ldo1OutVolt = 1800000U;
1641 /* LDO2 output set to 1.8V. */
1642 config->ldo2OutVolt = 1800000U;
1643 /* LDO3 output set to 1.2V. */
1644 config->ldo3OutVolt = 1200000U;
1645 /* LDO4 output set to 3.3V. */
1646 config->ldo4OutVolt = 3300000U;
1647 }
1648
PCA9422_GetDefaultEnModeConfig(pca9422_enmodecfg_t * enModeCfg)1649 void PCA9422_GetDefaultEnModeConfig(pca9422_enmodecfg_t *enModeCfg)
1650 {
1651 /* Enable mode is always ON in all regulators */
1652 enModeCfg->sw1OutEnMode = kPCA9422_EnmodeOnAll;
1653 enModeCfg->sw2OutEnMode = kPCA9422_EnmodeOnAll;
1654 enModeCfg->sw3OutEnMode = kPCA9422_EnmodeOnAll;
1655 enModeCfg->sw4OutEnMode = kPCA9422_EnmodeOnAll;
1656 enModeCfg->ldo1OutEnMode = kPCA9422_EnmodeOnAll;
1657 enModeCfg->ldo2OutEnMode = kPCA9422_EnmodeOnAll;
1658 enModeCfg->ldo3OutEnMode = kPCA9422_EnmodeOnAll;
1659 enModeCfg->ldo4OutEnMode = kPCA9422_EnmodeOnAll;
1660 }
1661
PCA9422_GetDefaultRegEnableConfig(pca9422_regulatoren_t * regEnCfg)1662 void PCA9422_GetDefaultRegEnableConfig(pca9422_regulatoren_t *regEnCfg)
1663 {
1664 /* All regulators enable in RUN state. */
1665 regEnCfg->sw1Enable = true;
1666 regEnCfg->sw2Enable = true;
1667 regEnCfg->sw3Enable = true;
1668 regEnCfg->sw4Enable = true;
1669 regEnCfg->ldo1Enable = true;
1670 regEnCfg->ldo2Enable = true;
1671 regEnCfg->ldo3Enable = true;
1672 regEnCfg->ldo4Enable = true;
1673 }
1674
PCA9422_GetLDO1EnMode(pca9422_handle_t * handle,bool * enmode)1675 void PCA9422_GetLDO1EnMode(pca9422_handle_t *handle, bool *enmode)
1676 {
1677 bool result;
1678 uint8_t regVal;
1679
1680 result = PCA9422_ReadRegs(handle, PCA9422_LDO1_CFG2, ®Val, 1U);
1681 if (result == false)
1682 {
1683 LOG_INFO("Error I2C data Read[0x4A]\r\n");
1684 }
1685 else
1686 {
1687 *enmode = ((regVal & PCA9422_LDO1_CFG2_L1_ENMODE) != 0U) ? true : false;
1688 }
1689 }
1690
PCA9422_SetLDO1EnMode(pca9422_handle_t * handle,bool enmode)1691 void PCA9422_SetLDO1EnMode(pca9422_handle_t *handle, bool enmode)
1692 {
1693 bool result;
1694
1695 result = PCA9422_ModifyReg(handle, PCA9422_LDO1_CFG2, PCA9422_LDO1_CFG2_L1_ENMODE, (uint8_t)enmode);
1696 if (result == false)
1697 {
1698 LOG_INFO("Error I2C data write[0x4A]\r\n");
1699 }
1700 }
1701
PCA9422_GetRegulatorEnMode(pca9422_handle_t * handle,pca9422_regulator_t reg,pca9422_enmode_t * enmode)1702 void PCA9422_GetRegulatorEnMode(pca9422_handle_t *handle, pca9422_regulator_t reg, pca9422_enmode_t *enmode)
1703 {
1704 uint8_t regVal, regAddr;
1705 bool result, ldo1EnMode = false;
1706
1707 switch (reg)
1708 {
1709 case kPCA9422_RegulatorSwitch1:
1710 /* Read BUCK1CTRL */
1711 regAddr = PCA9422_BUCK1CTRL;
1712 result = PCA9422_ReadRegs(handle, regAddr, ®Val, 1U);
1713 if (result == false)
1714 {
1715 goto out;
1716 }
1717 regVal = regVal & PCA9422_BUCKXCTRL_BX_ENMODE;
1718 *enmode = (pca9422_enmode_t)regVal;
1719 break;
1720 case kPCA9422_RegulatorSwitch2:
1721 /* Read BUCK2CTRL */
1722 regAddr = PCA9422_BUCK2CTRL;
1723 result = PCA9422_ReadRegs(handle, regAddr, ®Val, 1U);
1724 if (result == false)
1725 {
1726 goto out;
1727 }
1728 regVal = regVal & PCA9422_BUCKXCTRL_BX_ENMODE;
1729 *enmode = (pca9422_enmode_t)regVal;
1730 break;
1731 case kPCA9422_RegulatorSwitch3:
1732 /* Read BUCK3CTRL */
1733 regAddr = PCA9422_BUCK3CTRL;
1734 result = PCA9422_ReadRegs(handle, regAddr, ®Val, 1U);
1735 if (result == false)
1736 {
1737 goto out;
1738 }
1739 regVal = regVal & PCA9422_BUCKXCTRL_BX_ENMODE;
1740 *enmode = (pca9422_enmode_t)regVal;
1741 break;
1742 case kPCA9422_RegulatorSwitch4:
1743 /* Read SW4_BB_CFG2 */
1744 regAddr = PCA9422_SW4_BB_CFG2;
1745 result = PCA9422_ReadRegs(handle, regAddr, ®Val, 1U);
1746 if (result == false)
1747 {
1748 goto out;
1749 }
1750 regVal = (regVal & PCA9422_SW4_BB_CFG2_BB_ENMODE) >> 2U;
1751 *enmode = (pca9422_enmode_t)(regVal);
1752 break;
1753 case kPCA9422_RegulatorLdo1:
1754 /* LDO1 ENMODE just has always on or off.
1755 * If it is always on mode, enmode will set kPCA9422_EnmodeOnAll
1756 * and if it is off, enmode will set kPCA9422_EnmodeOnActive */
1757 PCA9422_GetLDO1EnMode(handle, &ldo1EnMode);
1758 *enmode = ldo1EnMode ? kPCA9422_EnmodeOnAll : kPCA9422_EnmodeOnActive;
1759 break;
1760 case kPCA9422_RegulatorLdo2:
1761 /* Read LDO2_CFG */
1762 regAddr = PCA9422_LDO2_CFG;
1763 result = PCA9422_ReadRegs(handle, regAddr, ®Val, 1U);
1764 if (result == false)
1765 {
1766 goto out;
1767 }
1768 regVal = regVal & PCA9422_LDO2_CFG_L2_ENMODE;
1769 *enmode = (pca9422_enmode_t)regVal;
1770 break;
1771 case kPCA9422_RegulatorLdo3:
1772 /* Read LDO3_CFG */
1773 regAddr = PCA9422_LDO3_CFG;
1774 result = PCA9422_ReadRegs(handle, regAddr, ®Val, 1U);
1775 if (result == false)
1776 {
1777 goto out;
1778 }
1779 regVal = regVal & PCA9422_LDO3_CFG_L3_ENMODE;
1780 *enmode = (pca9422_enmode_t)regVal;
1781 break;
1782 case kPCA9422_RegulatorLdo4:
1783 /* Read LDO4_CFG */
1784 regAddr = PCA9422_LDO4_CFG;
1785 result = PCA9422_ReadRegs(handle, regAddr, ®Val, 1U);
1786 if (result == false)
1787 {
1788 goto out;
1789 }
1790 regVal = regVal & PCA9422_LDO4_CFG_L4_ENMODE;
1791 *enmode = (pca9422_enmode_t)regVal;
1792 break;
1793 default:
1794 LOG_INFO("Error Invalid regulator\r\n");
1795 *enmode = (pca9422_enmode_t)kPCA9422_EnmodeOnAll;
1796 break;
1797 }
1798 return;
1799
1800 out:
1801 LOG_INFO("Error I2C data read[0x%2X]\r\n", regAddr);
1802 return;
1803 }
1804
PCA9422_SetRegulatorEnMode(pca9422_handle_t * handle,pca9422_regulator_t reg,pca9422_enmode_t enmode)1805 void PCA9422_SetRegulatorEnMode(pca9422_handle_t *handle, pca9422_regulator_t reg, pca9422_enmode_t enmode)
1806 {
1807 uint8_t regVal, regAddr, regMask;
1808 bool result, ldo1EnMode;
1809
1810 switch (reg)
1811 {
1812 case kPCA9422_RegulatorSwitch1:
1813 /* Write BUCK1CTRL */
1814 regAddr = PCA9422_BUCK1CTRL;
1815 regVal = (uint8_t)enmode;
1816 regMask = PCA9422_BUCKXCTRL_BX_ENMODE;
1817 break;
1818 case kPCA9422_RegulatorSwitch2:
1819 /* Write BUCK2CTRL */
1820 regAddr = PCA9422_BUCK2CTRL;
1821 regVal = (uint8_t)enmode;
1822 regMask = PCA9422_BUCKXCTRL_BX_ENMODE;
1823 break;
1824 case kPCA9422_RegulatorSwitch3:
1825 /* Write BUCK3CTRL */
1826 regAddr = PCA9422_BUCK3CTRL;
1827 regVal = (uint8_t)enmode;
1828 regMask = PCA9422_BUCKXCTRL_BX_ENMODE;
1829 break;
1830 case kPCA9422_RegulatorSwitch4:
1831 /* Write SW4_BB_CFG2 */
1832 regAddr = PCA9422_SW4_BB_CFG2;
1833 regVal = (uint8_t)enmode << 2U;
1834 regMask = PCA9422_SW4_BB_CFG2_BB_ENMODE;
1835 break;
1836 case kPCA9422_RegulatorLdo1:
1837 /* Set LDO1 with PCA9422_SeLDO1EnMode function */
1838 ldo1EnMode = (enmode == kPCA9422_EnmodeOnAll) ? true : false;
1839 PCA9422_SetLDO1EnMode(handle, ldo1EnMode);
1840 regAddr = 0xFF;
1841 break;
1842 case kPCA9422_RegulatorLdo2:
1843 /* Write LDO2_CFG */
1844 regAddr = PCA9422_LDO2_CFG;
1845 regVal = (uint8_t)enmode;
1846 regMask = PCA9422_LDO2_CFG_L2_ENMODE;
1847 break;
1848 case kPCA9422_RegulatorLdo3:
1849 /* Write LDO3_CFG */
1850 regAddr = PCA9422_LDO3_CFG;
1851 regVal = (uint8_t)enmode;
1852 regMask = PCA9422_LDO3_CFG_L3_ENMODE;
1853 break;
1854 case kPCA9422_RegulatorLdo4:
1855 /* Write LDO4_CFG */
1856 regAddr = PCA9422_LDO4_CFG;
1857 regVal = (uint8_t)enmode;
1858 regMask = PCA9422_LDO4_CFG_L4_ENMODE;
1859 break;
1860 default:
1861 LOG_INFO("Error Invalid regulator\r\n");
1862 regAddr = 0xFFU;
1863 break;
1864 }
1865
1866 if (regAddr != 0xFFU)
1867 {
1868 result = PCA9422_ModifyReg(handle, regAddr, regMask, regVal);
1869 if (result == false)
1870 {
1871 LOG_INFO("Error I2C data write[0x%2X]\r\n", regAddr);
1872 }
1873 }
1874 }
1875
PCA9422_GetRegulatorLPMode(pca9422_handle_t * handle,pca9422_regulator_t reg,pca9422_reg_lpmode_t * lpmode)1876 void PCA9422_GetRegulatorLPMode(pca9422_handle_t *handle, pca9422_regulator_t reg, pca9422_reg_lpmode_t *lpmode)
1877 {
1878 uint8_t regVal, regAddr;
1879 bool result;
1880
1881 switch (reg)
1882 {
1883 case kPCA9422_RegulatorSwitch1:
1884 /* Read BUCK1CTRL */
1885 regAddr = PCA9422_BUCK1CTRL;
1886 result = PCA9422_ReadRegs(handle, regAddr, ®Val, 1U);
1887 if (result == false)
1888 {
1889 goto out;
1890 }
1891 regVal = (regVal & PCA9422_BUCKXCTRL_BX_LPMODE) >> 4U;
1892 *lpmode = (pca9422_reg_lpmode_t)regVal;
1893 break;
1894 case kPCA9422_RegulatorSwitch2:
1895 /* Read BUCK2CTRL */
1896 regAddr = PCA9422_BUCK2CTRL;
1897 result = PCA9422_ReadRegs(handle, regAddr, ®Val, 1U);
1898 if (result == false)
1899 {
1900 goto out;
1901 }
1902 regVal = (regVal & PCA9422_BUCKXCTRL_BX_LPMODE) >> 4U;
1903 *lpmode = (pca9422_reg_lpmode_t)regVal;
1904 break;
1905 case kPCA9422_RegulatorSwitch3:
1906 /* Read BUCK3CTRL */
1907 regAddr = PCA9422_BUCK3CTRL;
1908 result = PCA9422_ReadRegs(handle, regAddr, ®Val, 1U);
1909 if (result == false)
1910 {
1911 goto out;
1912 }
1913 regVal = (regVal & PCA9422_BUCKXCTRL_BX_LPMODE) >> 4U;
1914 *lpmode = (pca9422_reg_lpmode_t)regVal;
1915 break;
1916 case kPCA9422_RegulatorSwitch4:
1917 /* Read SW4_BB_CFG2 */
1918 regAddr = PCA9422_SW4_BB_CFG2;
1919 result = PCA9422_ReadRegs(handle, regAddr, ®Val, 1U);
1920 if (result == false)
1921 {
1922 goto out;
1923 }
1924 regVal = regVal & PCA9422_SW4_BB_CFG2_BB_LPMODE;
1925 *lpmode = (pca9422_reg_lpmode_t)regVal;
1926 break;
1927 case kPCA9422_RegulatorLdo1:
1928 /* There is no low power mode */
1929 *lpmode = (pca9422_reg_lpmode_t)kPCA9422_LPmodeNormal;
1930 LOG_INFO("Error LDO1 doesn't support LP mode\r\n");
1931 break;
1932 case kPCA9422_RegulatorLdo2:
1933 /* Read LDO2_CFG */
1934 regAddr = PCA9422_LDO2_CFG;
1935 result = PCA9422_ReadRegs(handle, regAddr, ®Val, 1U);
1936 if (result == false)
1937 {
1938 goto out;
1939 }
1940 regVal = regVal & PCA9422_LDO2_CFG_L2_LPMODE;
1941 *lpmode = (pca9422_reg_lpmode_t)regVal;
1942 if (regVal == (uint8_t)kPCA9422_LDO23LPmodeAtRunState)
1943 {
1944 *lpmode = (pca9422_reg_lpmode_t)kPCA9422_LPmodeForcedLPM;
1945 }
1946 else if (regVal == (uint8_t)kPCA9422_LDO23LPmodeAtStandbyDPStandby)
1947 {
1948 *lpmode = (pca9422_reg_lpmode_t)kPCA9422_LPmodeAtStandbyDPStandby;
1949 }
1950 else if (regVal == (uint8_t)kPCA9422_LDO23LPmodeAtDPStandby)
1951 {
1952 *lpmode = (pca9422_reg_lpmode_t)kPCA9422_LPpmodeAtDPstandby;
1953 }
1954 else
1955 {
1956 *lpmode = (pca9422_reg_lpmode_t)kPCA9422_LPmodeNormal;
1957 }
1958 break;
1959 case kPCA9422_RegulatorLdo3:
1960 /* Read LDO3_CFG */
1961 regAddr = PCA9422_LDO3_CFG;
1962 result = PCA9422_ReadRegs(handle, regAddr, ®Val, 1U);
1963 if (result == false)
1964 {
1965 goto out;
1966 }
1967 regVal = regVal & PCA9422_LDO3_CFG_L3_LPMODE;
1968 *lpmode = (pca9422_reg_lpmode_t)regVal;
1969 if (regVal == (uint8_t)kPCA9422_LDO23LPmodeAtRunState)
1970 {
1971 *lpmode = (pca9422_reg_lpmode_t)kPCA9422_LPmodeForcedLPM;
1972 }
1973 else if (regVal == (uint8_t)kPCA9422_LDO23LPmodeAtStandbyDPStandby)
1974 {
1975 *lpmode = (pca9422_reg_lpmode_t)kPCA9422_LPmodeAtStandbyDPStandby;
1976 }
1977 else if (regVal == (uint8_t)kPCA9422_LDO23LPmodeAtDPStandby)
1978 {
1979 *lpmode = (pca9422_reg_lpmode_t)kPCA9422_LPpmodeAtDPstandby;
1980 }
1981 else
1982 {
1983 *lpmode = (pca9422_reg_lpmode_t)kPCA9422_LPmodeNormal;
1984 }
1985 break;
1986 case kPCA9422_RegulatorLdo4:
1987 /* There is no low power mode */
1988 *lpmode = (pca9422_reg_lpmode_t)kPCA9422_LPmodeNormal;
1989 LOG_INFO("Error LDO4 doesn't support LP mode\r\n");
1990 break;
1991 default:
1992 LOG_INFO("Error Invalid regulator\r\n");
1993 *lpmode = (pca9422_reg_lpmode_t)kPCA9422_LPmodeNormal;
1994 break;
1995 }
1996 return;
1997
1998 out:
1999 LOG_INFO("Error I2C data read[0x%2X]\r\n", regAddr);
2000 return;
2001 }
2002
PCA9422_SetRegulatorLPMode(pca9422_handle_t * handle,pca9422_regulator_t reg,pca9422_reg_lpmode_t lpmode)2003 void PCA9422_SetRegulatorLPMode(pca9422_handle_t *handle, pca9422_regulator_t reg, pca9422_reg_lpmode_t lpmode)
2004 {
2005 uint8_t regVal, regAddr, regMask;
2006 bool result;
2007
2008 switch (reg)
2009 {
2010 case kPCA9422_RegulatorSwitch1:
2011 /* Write BUCK1CTRL */
2012 regAddr = PCA9422_BUCK1CTRL;
2013 regVal = (uint8_t)lpmode << 4U;
2014 regMask = PCA9422_BUCKXCTRL_BX_LPMODE;
2015 break;
2016 case kPCA9422_RegulatorSwitch2:
2017 /* Write BUCK2CTRL */
2018 regAddr = PCA9422_BUCK2CTRL;
2019 regVal = (uint8_t)lpmode << 4U;
2020 regMask = PCA9422_BUCKXCTRL_BX_LPMODE;
2021 break;
2022 case kPCA9422_RegulatorSwitch3:
2023 /* Write BUCK3CTRL */
2024 regAddr = PCA9422_BUCK3CTRL;
2025 regVal = (uint8_t)lpmode << 4U;
2026 regMask = PCA9422_BUCKXCTRL_BX_LPMODE;
2027 break;
2028 case kPCA9422_RegulatorSwitch4:
2029 /* Write SW4_BB_CFG2 */
2030 regAddr = PCA9422_SW4_BB_CFG2;
2031 regVal = (uint8_t)lpmode;
2032 regMask = PCA9422_SW4_BB_CFG2_BB_LPMODE;
2033 break;
2034 case kPCA9422_RegulatorLdo1:
2035 /* There is no low power mode */
2036 LOG_INFO("Error LDO1 doesn't support LP mode\r\n");
2037 regAddr = 0xFFU;
2038 break;
2039 case kPCA9422_RegulatorLdo2:
2040 /* Write LDO2_CFG */
2041 regAddr = PCA9422_LDO2_CFG;
2042 if (lpmode == kPCA9422_LPmodeForcedLPM)
2043 {
2044 regVal = (uint8_t)kPCA9422_LDO23LPmodeAtRunState;
2045 }
2046 else if (lpmode == kPCA9422_LPmodeAtStandbyDPStandby)
2047 {
2048 regVal = (uint8_t)kPCA9422_LDO23LPmodeAtStandbyDPStandby;
2049 }
2050 else if (lpmode == kPCA9422_LPpmodeAtDPstandby)
2051 {
2052 regVal = (uint8_t)kPCA9422_LDO23LPmodeAtDPStandby;
2053 }
2054 else
2055 {
2056 regVal = (uint8_t)kPCA9422_LDO23LPmodeNormal;
2057 }
2058 regMask = PCA9422_LDO2_CFG_L2_LPMODE;
2059 break;
2060 case kPCA9422_RegulatorLdo3:
2061 /* Write LDO3_CFG */
2062 regAddr = PCA9422_LDO3_CFG;
2063 if (lpmode == kPCA9422_LPmodeForcedLPM)
2064 {
2065 regVal = (uint8_t)kPCA9422_LDO23LPmodeAtRunState;
2066 }
2067 else if (lpmode == kPCA9422_LPmodeAtStandbyDPStandby)
2068 {
2069 regVal = (uint8_t)kPCA9422_LDO23LPmodeAtStandbyDPStandby;
2070 }
2071 else if (lpmode == kPCA9422_LPpmodeAtDPstandby)
2072 {
2073 regVal = (uint8_t)kPCA9422_LDO23LPmodeAtDPStandby;
2074 }
2075 else
2076 {
2077 regVal = (uint8_t)kPCA9422_LDO23LPmodeNormal;
2078 }
2079 regMask = PCA9422_LDO3_CFG_L3_LPMODE;
2080 break;
2081 case kPCA9422_RegulatorLdo4:
2082 /* There is no low power mode */
2083 LOG_INFO("Error LDO4 doesn't support LP mode\r\n");
2084 regAddr = 0xFFU;
2085 break;
2086 default:
2087 LOG_INFO("Error Invalid regulator\r\n");
2088 regAddr = 0xFFU;
2089 break;
2090 }
2091
2092 if (regAddr != 0xFFU)
2093 {
2094 result = PCA9422_ModifyReg(handle, regAddr, regMask, regVal);
2095 if (result == false)
2096 {
2097 LOG_INFO("Error I2C data write[0x%2X]\r\n", regAddr);
2098 }
2099 }
2100 return;
2101 }
2102
PCA9422_SetRegulatorVoltage(pca9422_handle_t * handle,pca9422_regulator_t reg,pca9422_vout_t vout,uint32_t volt)2103 void PCA9422_SetRegulatorVoltage(pca9422_handle_t *handle, pca9422_regulator_t reg, pca9422_vout_t vout, uint32_t volt)
2104 {
2105 uint8_t regVal, regAddr, regMask;
2106 bool result;
2107
2108 /* REG_LOCK - UNLOCK KEY */
2109 regVal = (uint8_t)kPCA9422_RegLockUnlockKey;
2110 regAddr = PCA9422_REG_LOCK;
2111 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
2112 if (result == false)
2113 {
2114 goto out;
2115 }
2116
2117 switch (reg)
2118 {
2119 case kPCA9422_RegulatorSwitch1:
2120 regVal = (uint8_t)PCA9422_BUCK1_OUT_VAL(volt);
2121 regMask = PCA9422_BUCKXOUT_DVS0_BX_DVS0;
2122 /* Check VOUT type */
2123 switch (vout)
2124 {
2125 case kPCA9422_RegSleepVout:
2126 regAddr = PCA9422_BUCK1OUT_SLEEP;
2127 break;
2128 case kPCA9422_RegStandbyVout:
2129 regAddr = PCA9422_BUCK1OUT_STBY;
2130 break;
2131 case kPCA9422_SWMaxVout:
2132 regAddr = PCA9422_BUCK1OUT_MAX_LIMIT;
2133 break;
2134 case kPCA9422_SWDVS0Vout:
2135 regAddr = PCA9422_BUCK1OUT_DVS0;
2136 break;
2137 case kPCA9422_SWDVS1Vout:
2138 regAddr = PCA9422_BUCK1OUT_DVS1;
2139 break;
2140 case kPCA9422_SWDVS2Vout:
2141 regAddr = PCA9422_BUCK1OUT_DVS2;
2142 break;
2143 case kPCA9422_SWDVS3Vout:
2144 regAddr = PCA9422_BUCK1OUT_DVS3;
2145 break;
2146 case kPCA9422_SWDVS4Vout:
2147 regAddr = PCA9422_BUCK1OUT_DVS4;
2148 break;
2149 case kPCA9422_SWDVS5Vout:
2150 regAddr = PCA9422_BUCK1OUT_DVS5;
2151 break;
2152 case kPCA9422_SWDVS6Vout:
2153 regAddr = PCA9422_BUCK1OUT_DVS6;
2154 break;
2155 case kPCA9422_SWDVS7Vout:
2156 regAddr = PCA9422_BUCK1OUT_DVS7;
2157 break;
2158 default:
2159 /* Not support */
2160 regAddr = 0xFFU;
2161 LOG_INFO("Error - SW1 doesn't support vout type(%d)\r\n", vout);
2162 break;
2163 }
2164 break;
2165
2166 case kPCA9422_RegulatorSwitch2:
2167 regVal = (uint8_t)PCA9422_BUCK2_OUT_VAL(volt);
2168 regMask = PCA9422_BUCKXOUT_DVS0_BX_DVS0;
2169 /* Check VOUT type */
2170 switch (vout)
2171 {
2172 case kPCA9422_RegSleepVout:
2173 regAddr = PCA9422_BUCK2OUT_SLEEP;
2174 break;
2175 case kPCA9422_RegStandbyVout:
2176 regAddr = PCA9422_BUCK2OUT_STBY;
2177 break;
2178 case kPCA9422_SWMaxVout:
2179 regAddr = PCA9422_BUCK2OUT_MAX_LIMIT;
2180 break;
2181 case kPCA9422_SWDVS0Vout:
2182 regAddr = PCA9422_BUCK2OUT_DVS0;
2183 break;
2184 case kPCA9422_SWDVS1Vout:
2185 regAddr = PCA9422_BUCK2OUT_DVS1;
2186 break;
2187 case kPCA9422_SWDVS2Vout:
2188 regAddr = PCA9422_BUCK2OUT_DVS2;
2189 break;
2190 case kPCA9422_SWDVS3Vout:
2191 regAddr = PCA9422_BUCK2OUT_DVS3;
2192 break;
2193 case kPCA9422_SWDVS4Vout:
2194 regAddr = PCA9422_BUCK2OUT_DVS4;
2195 break;
2196 case kPCA9422_SWDVS5Vout:
2197 regAddr = PCA9422_BUCK2OUT_DVS5;
2198 break;
2199 case kPCA9422_SWDVS6Vout:
2200 regAddr = PCA9422_BUCK2OUT_DVS6;
2201 break;
2202 case kPCA9422_SWDVS7Vout:
2203 regAddr = PCA9422_BUCK2OUT_DVS7;
2204 break;
2205 default:
2206 /* Not support */
2207 regAddr = 0xFFU;
2208 LOG_INFO("Error - SW2 doesn't support vout type(%d)\r\n", vout);
2209 break;
2210 }
2211 break;
2212
2213 case kPCA9422_RegulatorSwitch3:
2214 regVal = (uint8_t)PCA9422_BUCK3_OUT_VAL(volt);
2215 regMask = PCA9422_BUCKXOUT_DVS0_BX_DVS0;
2216 /* Check VOUT type */
2217 switch (vout)
2218 {
2219 case kPCA9422_RegSleepVout:
2220 regAddr = PCA9422_BUCK3OUT_SLEEP;
2221 break;
2222 case kPCA9422_RegStandbyVout:
2223 regAddr = PCA9422_BUCK3OUT_STBY;
2224 break;
2225 case kPCA9422_SWMaxVout:
2226 regAddr = PCA9422_BUCK3OUT_MAX_LIMIT;
2227 break;
2228 case kPCA9422_SWDVS0Vout:
2229 regAddr = PCA9422_BUCK3OUT_DVS0;
2230 break;
2231 case kPCA9422_SWDVS1Vout:
2232 regAddr = PCA9422_BUCK3OUT_DVS1;
2233 break;
2234 case kPCA9422_SWDVS2Vout:
2235 regAddr = PCA9422_BUCK3OUT_DVS2;
2236 break;
2237 case kPCA9422_SWDVS3Vout:
2238 regAddr = PCA9422_BUCK3OUT_DVS3;
2239 break;
2240 case kPCA9422_SWDVS4Vout:
2241 regAddr = PCA9422_BUCK3OUT_DVS4;
2242 break;
2243 case kPCA9422_SWDVS5Vout:
2244 regAddr = PCA9422_BUCK3OUT_DVS5;
2245 break;
2246 case kPCA9422_SWDVS6Vout:
2247 regAddr = PCA9422_BUCK3OUT_DVS6;
2248 break;
2249 case kPCA9422_SWDVS7Vout:
2250 regAddr = PCA9422_BUCK3OUT_DVS7;
2251 break;
2252 default:
2253 /* Not support */
2254 regAddr = 0xFFU;
2255 LOG_INFO("Error - SW3 doesn't support vout type(%d)\r\n", vout);
2256 break;
2257 }
2258 break;
2259 case kPCA9422_RegulatorSwitch4:
2260 regVal = (uint8_t)PCA9422_BB_OUT_VAL(volt);
2261 regMask = (uint8_t)PCA9422_SW4_BB_CFG3_BB_VOUT;
2262 /* Check VOUT type */
2263 switch (vout)
2264 {
2265 case kPCA9422_RegVout:
2266 regAddr = PCA9422_SW4_BB_CFG3;
2267 break;
2268 case kPCA9422_RegSleepVout:
2269 regAddr = PCA9422_SW4_BB_VOUT_SLEEP;
2270 break;
2271 case kPCA9422_RegStandbyVout:
2272 regAddr = PCA9422_SW4_BB_CFG4;
2273 break;
2274 case kPCA9422_SWMaxVout:
2275 regAddr = PCA9422_SW4_BB_MAX_LIMIT;
2276 break;
2277 case kPCA9422_BBMinVout:
2278 regAddr = PCA9422_SW4_BB_MIN_LIMIT;
2279 break;
2280 default:
2281 /* Not support */
2282 regAddr = 0xFFU;
2283 LOG_INFO("Error - SW4 doesn't support vout type(%d)\r\n", vout);
2284 break;
2285 }
2286 break;
2287
2288 case kPCA9422_RegulatorLdo1:
2289 regVal = (uint8_t)PCA9422_LDO1_OUT_VAL(volt);
2290 regMask = PCA9422_LDO1_CFG1_L1_OUT;
2291 switch (vout)
2292 {
2293 case kPCA9422_RegVout:
2294 regAddr = PCA9422_LDO1_CFG1;
2295 break;
2296 case kPCA9422_RegSleepVout:
2297 case kPCA9422_RegStandbyVout:
2298 /* Not support */
2299 regAddr = 0xFFU;
2300 LOG_INFO("LDO1 doesn't support sleep/standby vout type(%d)\r\n", vout);
2301 break;
2302 default:
2303 /* Not support */
2304 regAddr = 0xFFU;
2305 LOG_INFO("Error - LDO1 doesn't support vout type(%d)\r\n", vout);
2306 break;
2307 }
2308 break;
2309
2310 case kPCA9422_RegulatorLdo2:
2311 regVal = (uint8_t)PCA9422_LDO23_OUT_VAL(volt);
2312 regMask = PCA9422_LDO2_OUT_L2_OUT;
2313 switch (vout)
2314 {
2315 case kPCA9422_RegVout:
2316 regAddr = PCA9422_LDO2_OUT;
2317 break;
2318 case kPCA9422_RegSleepVout:
2319 regAddr = PCA9422_LDO2_OUT_SLEEP;
2320 break;
2321 case kPCA9422_RegStandbyVout:
2322 regAddr = PCA9422_LDO2_OUT_STBY;
2323 break;
2324 default:
2325 /* Not support */
2326 regAddr = 0xFFU;
2327 LOG_INFO("Error - LDO2 doesn't support vout type(%d)\r\n", vout);
2328 break;
2329 }
2330 break;
2331
2332 case kPCA9422_RegulatorLdo3:
2333 regVal = (uint8_t)PCA9422_LDO23_OUT_VAL(volt);
2334 regMask = PCA9422_LDO3_OUT_L3_OUT;
2335 switch (vout)
2336 {
2337 case kPCA9422_RegVout:
2338 regAddr = PCA9422_LDO3_OUT;
2339 break;
2340 case kPCA9422_RegSleepVout:
2341 regAddr = PCA9422_LDO3_OUT_SLEEP;
2342 break;
2343 case kPCA9422_RegStandbyVout:
2344 regAddr = PCA9422_LDO3_OUT_STBY;
2345 break;
2346 default:
2347 /* Not support */
2348 regAddr = 0xFFU;
2349 LOG_INFO("Error - LDO3 doesn't support vout type(%d)\r\n", vout);
2350 break;
2351 }
2352 break;
2353 case kPCA9422_RegulatorLdo4:
2354 regVal = (uint8_t)PCA9422_LDO4_OUT_VAL(volt);
2355 regMask = PCA9422_LDO4_OUT_L4_OUT;
2356 switch (vout)
2357 {
2358 case kPCA9422_RegVout:
2359 regAddr = PCA9422_LDO4_OUT;
2360 break;
2361 case kPCA9422_RegSleepVout:
2362 regAddr = PCA9422_LDO4_OUT_SLEEP;
2363 break;
2364 case kPCA9422_RegStandbyVout:
2365 regAddr = PCA9422_LDO4_OUT_STBY;
2366 break;
2367 default:
2368 /* Not support */
2369 regAddr = 0xFFU;
2370 LOG_INFO("Error - LDO4 doesn't support vout type(%d)\r\n", vout);
2371 break;
2372 }
2373 break;
2374 default:
2375 regAddr = 0xFFU;
2376 LOG_INFO("Error Invalid regulator\r\n");
2377 break;
2378 }
2379
2380 if (regAddr != 0xFFU)
2381 {
2382 result = PCA9422_ModifyReg(handle, regAddr, regMask, regVal);
2383 if (result == false)
2384 {
2385 goto out;
2386 }
2387 /* REG_LOCK - UNLOCK KEY */
2388 regVal = (uint8_t)kPCA9422_RegLockUnlockKey;
2389 regAddr = PCA9422_REG_LOCK;
2390 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
2391 if (result == false)
2392 {
2393 goto out;
2394 }
2395 }
2396 return;
2397
2398 out:
2399 LOG_INFO("Error I2C data write[0x%2X]\r\n", regAddr);
2400 return;
2401 }
2402
PCA9422_GetRegulatorVoltage(pca9422_handle_t * handle,pca9422_regulator_t reg,pca9422_vout_t vout,uint32_t * volt)2403 void PCA9422_GetRegulatorVoltage(pca9422_handle_t *handle, pca9422_regulator_t reg, pca9422_vout_t vout, uint32_t *volt)
2404 {
2405 uint8_t regVal, regAddr, regMask = 0U;
2406 bool result = true;
2407
2408 /* REG_LOCK - UNLOCK KEY */
2409 regVal = (uint8_t)kPCA9422_RegLockUnlockKey;
2410 regAddr = PCA9422_REG_LOCK;
2411 result = PCA9422_WriteRegs(handle, regAddr, ®Val, 1U);
2412 if (result == false)
2413 {
2414 goto out;
2415 }
2416
2417 switch (reg)
2418 {
2419 case kPCA9422_RegulatorSwitch1:
2420 regMask = PCA9422_BUCKXOUT_DVS0_BX_DVS0;
2421 /* Check VOUT type */
2422 switch (vout)
2423 {
2424 case kPCA9422_RegSleepVout:
2425 regAddr = PCA9422_BUCK1OUT_SLEEP;
2426 break;
2427 case kPCA9422_RegStandbyVout:
2428 regAddr = PCA9422_BUCK1OUT_STBY;
2429 break;
2430 case kPCA9422_SWMaxVout:
2431 regAddr = PCA9422_BUCK1OUT_MAX_LIMIT;
2432 break;
2433 case kPCA9422_SWDVS0Vout:
2434 regAddr = PCA9422_BUCK1OUT_DVS0;
2435 break;
2436 case kPCA9422_SWDVS1Vout:
2437 regAddr = PCA9422_BUCK1OUT_DVS1;
2438 break;
2439 case kPCA9422_SWDVS2Vout:
2440 regAddr = PCA9422_BUCK1OUT_DVS2;
2441 break;
2442 case kPCA9422_SWDVS3Vout:
2443 regAddr = PCA9422_BUCK1OUT_DVS3;
2444 break;
2445 case kPCA9422_SWDVS4Vout:
2446 regAddr = PCA9422_BUCK1OUT_DVS4;
2447 break;
2448 case kPCA9422_SWDVS5Vout:
2449 regAddr = PCA9422_BUCK1OUT_DVS5;
2450 break;
2451 case kPCA9422_SWDVS6Vout:
2452 regAddr = PCA9422_BUCK1OUT_DVS6;
2453 break;
2454 case kPCA9422_SWDVS7Vout:
2455 regAddr = PCA9422_BUCK1OUT_DVS7;
2456 break;
2457 default:
2458 /* Not support */
2459 regAddr = 0xFFU;
2460 LOG_INFO("Error - SW1 doesn't support vout type(%d)\r\n", vout);
2461 break;
2462 }
2463 if (regAddr != 0xFFU)
2464 {
2465 result = PCA9422_ReadRegs(handle, regAddr, ®Val, 1U);
2466 if (result == false)
2467 goto out;
2468 regVal = regVal & regMask;
2469 *volt = PCA9422_BUCK1_OUT_VOLT(regVal);
2470 }
2471 else
2472 {
2473 *volt = 0U;
2474 }
2475 break;
2476
2477 case kPCA9422_RegulatorSwitch2:
2478 regMask = PCA9422_BUCKXOUT_DVS0_BX_DVS0;
2479 /* Check VOUT type */
2480 switch (vout)
2481 {
2482 case kPCA9422_RegSleepVout:
2483 regAddr = PCA9422_BUCK2OUT_SLEEP;
2484 break;
2485 case kPCA9422_RegStandbyVout:
2486 regAddr = PCA9422_BUCK2OUT_STBY;
2487 break;
2488 case kPCA9422_SWMaxVout:
2489 regAddr = PCA9422_BUCK2OUT_MAX_LIMIT;
2490 break;
2491 case kPCA9422_SWDVS0Vout:
2492 regAddr = PCA9422_BUCK2OUT_DVS0;
2493 break;
2494 case kPCA9422_SWDVS1Vout:
2495 regAddr = PCA9422_BUCK2OUT_DVS1;
2496 break;
2497 case kPCA9422_SWDVS2Vout:
2498 regAddr = PCA9422_BUCK2OUT_DVS2;
2499 break;
2500 case kPCA9422_SWDVS3Vout:
2501 regAddr = PCA9422_BUCK2OUT_DVS3;
2502 break;
2503 case kPCA9422_SWDVS4Vout:
2504 regAddr = PCA9422_BUCK2OUT_DVS4;
2505 break;
2506 case kPCA9422_SWDVS5Vout:
2507 regAddr = PCA9422_BUCK2OUT_DVS5;
2508 break;
2509 case kPCA9422_SWDVS6Vout:
2510 regAddr = PCA9422_BUCK2OUT_DVS6;
2511 break;
2512 case kPCA9422_SWDVS7Vout:
2513 regAddr = PCA9422_BUCK2OUT_DVS7;
2514 break;
2515 default:
2516 /* Not support */
2517 regAddr = 0xFFU;
2518 LOG_INFO("Error - SW2 doesn't support vout type(%d)\r\n", vout);
2519 break;
2520 }
2521 if (regAddr != 0xFFU)
2522 {
2523 result = PCA9422_ReadRegs(handle, regAddr, ®Val, 1U);
2524 if (result == false)
2525 goto out;
2526 regVal = regVal & regMask;
2527 *volt = PCA9422_BUCK2_OUT_VOLT(regVal);
2528 }
2529 else
2530 {
2531 *volt = 0U;
2532 }
2533 break;
2534
2535 case kPCA9422_RegulatorSwitch3:
2536 regMask = PCA9422_BUCKXOUT_DVS0_BX_DVS0;
2537 /* Check VOUT type */
2538 switch (vout)
2539 {
2540 case kPCA9422_RegSleepVout:
2541 regAddr = PCA9422_BUCK3OUT_SLEEP;
2542 break;
2543 case kPCA9422_RegStandbyVout:
2544 regAddr = PCA9422_BUCK3OUT_STBY;
2545 break;
2546 case kPCA9422_SWMaxVout:
2547 regAddr = PCA9422_BUCK3OUT_MAX_LIMIT;
2548 break;
2549 case kPCA9422_SWDVS0Vout:
2550 regAddr = PCA9422_BUCK3OUT_DVS0;
2551 break;
2552 case kPCA9422_SWDVS1Vout:
2553 regAddr = PCA9422_BUCK3OUT_DVS1;
2554 break;
2555 case kPCA9422_SWDVS2Vout:
2556 regAddr = PCA9422_BUCK3OUT_DVS2;
2557 break;
2558 case kPCA9422_SWDVS3Vout:
2559 regAddr = PCA9422_BUCK3OUT_DVS3;
2560 break;
2561 case kPCA9422_SWDVS4Vout:
2562 regAddr = PCA9422_BUCK3OUT_DVS4;
2563 break;
2564 case kPCA9422_SWDVS5Vout:
2565 regAddr = PCA9422_BUCK3OUT_DVS5;
2566 break;
2567 case kPCA9422_SWDVS6Vout:
2568 regAddr = PCA9422_BUCK3OUT_DVS6;
2569 break;
2570 case kPCA9422_SWDVS7Vout:
2571 regAddr = PCA9422_BUCK3OUT_DVS7;
2572 break;
2573 default:
2574 /* Not support */
2575 regAddr = 0xFFU;
2576 LOG_INFO("Error - SW3 doesn't support vout type(%d)\r\n", vout);
2577 break;
2578 }
2579 if (regAddr != 0xFFU)
2580 {
2581 result = PCA9422_ReadRegs(handle, regAddr, ®Val, 1U);
2582 if (result == false)
2583 goto out;
2584 regVal = regVal & regMask;
2585 *volt = PCA9422_BUCK3_OUT_VOLT(regVal);
2586 }
2587 else
2588 {
2589 *volt = 0U;
2590 }
2591 break;
2592 case kPCA9422_RegulatorSwitch4:
2593 regMask = (uint8_t)PCA9422_SW4_BB_CFG3_BB_VOUT;
2594 /* Check VOUT type */
2595 switch (vout)
2596 {
2597 case kPCA9422_RegVout:
2598 regAddr = PCA9422_SW4_BB_CFG3;
2599 break;
2600 case kPCA9422_RegSleepVout:
2601 regAddr = PCA9422_SW4_BB_VOUT_SLEEP;
2602 break;
2603 case kPCA9422_RegStandbyVout:
2604 regAddr = PCA9422_SW4_BB_CFG4;
2605 break;
2606 case kPCA9422_SWMaxVout:
2607 regAddr = PCA9422_SW4_BB_MAX_LIMIT;
2608 break;
2609 case kPCA9422_BBMinVout:
2610 regAddr = PCA9422_SW4_BB_MIN_LIMIT;
2611 break;
2612 default:
2613 /* Not support */
2614 regAddr = 0xFFU;
2615 LOG_INFO("Error - SW4 doesn't support vout type(%d)\r\n", vout);
2616 break;
2617 }
2618 if (regAddr != 0xFFU)
2619 {
2620 result = PCA9422_ReadRegs(handle, regAddr, ®Val, 1U);
2621 if (result == false)
2622 {
2623 goto out;
2624 }
2625 regVal = regVal & regMask;
2626 *volt = PCA9422_BB_OUT_VOLT((uint32_t)regVal);
2627 }
2628 else
2629 {
2630 *volt = 0U;
2631 }
2632 break;
2633
2634 case kPCA9422_RegulatorLdo1:
2635 /* Always ON LDO */
2636 regMask = PCA9422_LDO1_CFG1_L1_OUT;
2637 switch (vout)
2638 {
2639 case kPCA9422_RegVout ... kPCA9422_RegStandbyVout:
2640 regAddr = PCA9422_LDO1_CFG1;
2641 break;
2642 default:
2643 /* Not support */
2644 regAddr = 0xFFU;
2645 LOG_INFO("Error - LDO1 doesn't support vout type(%d)\r\n", vout);
2646 break;
2647 }
2648 if (regAddr != 0xFFU)
2649 {
2650 result = PCA9422_ReadRegs(handle, regAddr, ®Val, 1U);
2651 if (result == false)
2652 {
2653 goto out;
2654 }
2655 regVal = regVal & regMask;
2656 *volt = (uint32_t)PCA9422_LDO1_OUT_VOLT(regVal);
2657 }
2658 else
2659 {
2660 *volt = 0U;
2661 }
2662 break;
2663
2664 case kPCA9422_RegulatorLdo2:
2665 regMask = PCA9422_LDO2_OUT_L2_OUT;
2666 switch (vout)
2667 {
2668 case kPCA9422_RegVout:
2669 regAddr = PCA9422_LDO2_OUT;
2670 break;
2671 case kPCA9422_RegSleepVout:
2672 regAddr = PCA9422_LDO2_OUT_SLEEP;
2673 break;
2674 case kPCA9422_RegStandbyVout:
2675 regAddr = PCA9422_LDO2_OUT_STBY;
2676 break;
2677 default:
2678 /* Not support */
2679 regAddr = 0xFFU;
2680 LOG_INFO("Error - LDO2 doesn't support vout type(%d)\r\n", vout);
2681 break;
2682 }
2683 if (regAddr != 0xFFU)
2684 {
2685 result = PCA9422_ReadRegs(handle, regAddr, ®Val, 1U);
2686 if (result == false)
2687 {
2688 goto out;
2689 }
2690 regVal = regVal & regMask;
2691 *volt = (uint8_t)PCA9422_LDO23_OUT_VOLT(regVal);
2692 }
2693 else
2694 {
2695 *volt = 0U;
2696 }
2697 break;
2698
2699 case kPCA9422_RegulatorLdo3:
2700 regMask = PCA9422_LDO3_OUT_L3_OUT;
2701 switch (vout)
2702 {
2703 case kPCA9422_RegVout:
2704 regAddr = PCA9422_LDO3_OUT;
2705 break;
2706 case kPCA9422_RegSleepVout:
2707 regAddr = PCA9422_LDO3_OUT_SLEEP;
2708 break;
2709 case kPCA9422_RegStandbyVout:
2710 regAddr = PCA9422_LDO3_OUT_STBY;
2711 break;
2712 default:
2713 /* Not support */
2714 regAddr = 0xFFU;
2715 LOG_INFO("Error - LDO3 doesn't support vout type(%d)\r\n", vout);
2716 break;
2717 }
2718 if (regAddr != 0xFFU)
2719 {
2720 result = PCA9422_ReadRegs(handle, regAddr, ®Val, 1U);
2721 if (result == false)
2722 {
2723 goto out;
2724 }
2725 regVal = regVal & regMask;
2726 *volt = (uint8_t)PCA9422_LDO23_OUT_VOLT(regVal);
2727 }
2728 else
2729 {
2730 *volt = 0U;
2731 }
2732 break;
2733 case kPCA9422_RegulatorLdo4:
2734 regMask = PCA9422_LDO4_OUT_L4_OUT;
2735 switch (vout)
2736 {
2737 case kPCA9422_RegVout:
2738 regAddr = PCA9422_LDO4_OUT;
2739 break;
2740 case kPCA9422_RegSleepVout:
2741 regAddr = PCA9422_LDO4_OUT_SLEEP;
2742 break;
2743 case kPCA9422_RegStandbyVout:
2744 regAddr = PCA9422_LDO4_OUT_STBY;
2745 break;
2746 default:
2747 /* Not support */
2748 regAddr = 0xFFU;
2749 LOG_INFO("Error - LDO4 doesn't support vout type(%d)\r\n", vout);
2750 break;
2751 }
2752 if (regAddr != 0xFFU)
2753 {
2754 result = PCA9422_ReadRegs(handle, regAddr, ®Val, 1U);
2755 if (result == false)
2756 {
2757 goto out;
2758 }
2759 regVal = regVal & regMask;
2760 *volt = PCA9422_LDO4_OUT_VOLT(regVal);
2761 }
2762 else
2763 {
2764 *volt = 0U;
2765 }
2766 break;
2767
2768 default:
2769 *volt = 0U;
2770 LOG_INFO("Error Invalid regulator\r\n");
2771 break;
2772 }
2773 return;
2774
2775 out:
2776 LOG_INFO("Error I2C data write[0x%2X]\r\n", regAddr);
2777 *volt = 0U;
2778 return;
2779 }
2780
PCA9422_GetRegulatorStatus(pca9422_handle_t * handle)2781 uint8_t PCA9422_GetRegulatorStatus(pca9422_handle_t *handle)
2782 {
2783 bool result = true;
2784 uint8_t status = 0U;
2785
2786 /* powerGoodEnable must be configured to true, otherwise the status is always 0. */
2787 result = PCA9422_ReadRegs(handle, PCA9422_REG_STATUS, &status, 1U);
2788 if (!result)
2789 {
2790 assert(false);
2791 }
2792
2793 return status;
2794 }
2795
PCA9422_SwitchPowerMode(pca9422_handle_t * handle,pca9422_power_mode_t mode)2796 void PCA9422_SwitchPowerMode(pca9422_handle_t *handle, pca9422_power_mode_t mode)
2797 {
2798 uint32_t pinMode;
2799 uint8_t regVal;
2800 bool result;
2801
2802 switch (mode)
2803 {
2804 case kPCA9422_ActiveModeDVS0:
2805 case kPCA9422_ActiveModeDVS1:
2806 case kPCA9422_ActiveModeDVS2:
2807 case kPCA9422_ActiveModeDVS3:
2808 case kPCA9422_ActiveModeDVS4:
2809 case kPCA9422_ActiveModeDVS5:
2810 case kPCA9422_ActiveModeDVS6:
2811 case kPCA9422_ActiveModeDVS7:
2812 pinMode = 0x00U;
2813 break;
2814 case kPCA9422_StandbyMode:
2815 pinMode = 0x02U;
2816 break;
2817 case kPCA9422_DPStandbyMode:
2818 pinMode = 0x03U;
2819 break;
2820 case kPCA9422_SleepMode:
2821 pinMode = 0x01U;
2822 break;
2823 default:
2824 pinMode = 0x00U;
2825 break;
2826 }
2827 /* Switch by Pins */
2828 POWER_SetPmicMode((uint32_t)pinMode, kCfg_Run);
2829
2830 /* Read SYS_CFG1 */
2831 result = PCA9422_ReadRegs(handle, PCA9422_SYS_CFG1, ®Val, 1U);
2832 if (result == false)
2833 {
2834 LOG_INFO("Error I2C data Read[0x%2X]\r\n", PCA9422_SYS_CFG1);
2835 }
2836
2837 if ((regVal & PCA9422_SYS_CFG1_STANDBY_CTRL) != 0U)
2838 {
2839 /* Standby/DPStandby mode controlled by STANDBY_CFG bit */
2840 if (mode == kPCA9422_StandbyMode)
2841 {
2842 regVal = (uint8_t)kPCA9422_StandbyCfgStandby;
2843 result = PCA9422_ModifyReg(handle, PCA9422_SYS_CFG1, PCA9422_SYS_CFG1_STANDBY_CFG, regVal);
2844 }
2845 else if (mode == kPCA9422_DPStandbyMode)
2846 {
2847 regVal = (uint8_t)kPCA9422_StandbyCfgDPStandby;
2848 result = PCA9422_ModifyReg(handle, PCA9422_SYS_CFG1, PCA9422_SYS_CFG1_STANDBY_CFG, regVal);
2849 }
2850 else
2851 {
2852 /* Intentional empty. */
2853 }
2854
2855 if (!result)
2856 {
2857 LOG_INFO("Error I2C operation [0x%2X]\r\n", PCA9422_SYS_CFG1);
2858 }
2859 }
2860 }
2861
PCA9422_GetCurrentPowerMode(pca9422_handle_t * handle,pca9422_power_mode_t * mode)2862 bool PCA9422_GetCurrentPowerMode(pca9422_handle_t *handle, pca9422_power_mode_t *mode)
2863 {
2864 bool result = true;
2865 uint8_t regVal = 0U;
2866
2867 /* Read PWR_STATE */
2868 result = PCA9422_ReadRegs(handle, PCA9422_PWR_STATE, ®Val, 1U);
2869 regVal = regVal & PCA9422_PWR_STATE_PWR_MODE;
2870 *mode = (pca9422_power_mode_t)regVal;
2871
2872 return result;
2873 }
2874
PCA9422_GetCurrentEnMode(pca9422_handle_t * handle,pca9422_enmodecfg_t * config)2875 void PCA9422_GetCurrentEnMode(pca9422_handle_t *handle, pca9422_enmodecfg_t *config)
2876 {
2877 PCA9422_GetRegulatorEnMode(handle, kPCA9422_RegulatorSwitch1, &config->sw1OutEnMode);
2878 PCA9422_GetRegulatorEnMode(handle, kPCA9422_RegulatorSwitch2, &config->sw2OutEnMode);
2879 PCA9422_GetRegulatorEnMode(handle, kPCA9422_RegulatorSwitch3, &config->sw3OutEnMode);
2880 PCA9422_GetRegulatorEnMode(handle, kPCA9422_RegulatorSwitch4, &config->sw4OutEnMode);
2881 PCA9422_GetRegulatorEnMode(handle, kPCA9422_RegulatorLdo1, &config->ldo1OutEnMode);
2882 PCA9422_GetRegulatorEnMode(handle, kPCA9422_RegulatorLdo2, &config->ldo2OutEnMode);
2883 PCA9422_GetRegulatorEnMode(handle, kPCA9422_RegulatorLdo3, &config->ldo3OutEnMode);
2884 PCA9422_GetRegulatorEnMode(handle, kPCA9422_RegulatorLdo4, &config->ldo4OutEnMode);
2885 }
2886
PCA9422_GetStandbyControl(pca9422_handle_t * handle,pca9422_standby_ctrl_t * ctrl)2887 bool PCA9422_GetStandbyControl(pca9422_handle_t *handle, pca9422_standby_ctrl_t *ctrl)
2888 {
2889 bool result = true;
2890 uint8_t regVal = 0U;
2891
2892 /* Read SYS_CFG1 */
2893 result = PCA9422_ReadRegs(handle, PCA9422_SYS_CFG1, ®Val, 1U);
2894 regVal = regVal & PCA9422_SYS_CFG1_STANDBY_CTRL;
2895 *ctrl = (pca9422_standby_ctrl_t)regVal;
2896
2897 return result;
2898 }
2899
PCA9422_SetBuckDVSControl(pca9422_handle_t * handle,pca9422_regulator_t reg,uint8_t dvsCtrl)2900 void PCA9422_SetBuckDVSControl(pca9422_handle_t *handle, pca9422_regulator_t reg, uint8_t dvsCtrl)
2901 {
2902 uint8_t regVal, regAddr, regMask;
2903 bool result;
2904
2905 regAddr = PCA9422_BUCK123_DVS_CFG2;
2906 switch (reg)
2907 {
2908 case kPCA9422_RegulatorSwitch1:
2909 regMask = PCA9422_BUCK123_DVS_CFG2_B1_DVS_CTRL;
2910 regVal = (uint8_t)(dvsCtrl << MASK2SHIFT(PCA9422_BUCK123_DVS_CFG2_B1_DVS_CTRL));
2911 break;
2912 case kPCA9422_RegulatorSwitch2:
2913 regMask = PCA9422_BUCK123_DVS_CFG2_B2_DVS_CTRL;
2914 regVal = (uint8_t)(dvsCtrl << MASK2SHIFT(PCA9422_BUCK123_DVS_CFG2_B2_DVS_CTRL));
2915 break;
2916 case kPCA9422_RegulatorSwitch3:
2917 regMask = PCA9422_BUCK123_DVS_CFG2_B3_DVS_CTRL;
2918 regVal = (uint8_t)(dvsCtrl << MASK2SHIFT(PCA9422_BUCK123_DVS_CFG2_B3_DVS_CTRL));
2919 break;
2920 default:
2921 LOG_INFO("Error Invalid regulator\r\n");
2922 regAddr = 0xFFU;
2923 break;
2924 }
2925
2926 if (regAddr != 0xFFU)
2927 {
2928 result = PCA9422_ModifyReg(handle, regAddr, regMask, regVal);
2929 if (result == false)
2930 {
2931 LOG_INFO("Error I2C data write[0x%2X]\r\n", regAddr);
2932 }
2933 }
2934 return;
2935 }
2936
PCA9422_SetEnableRegulatorRunState(pca9422_handle_t * handle,pca9422_regulator_t reg,bool enable)2937 void PCA9422_SetEnableRegulatorRunState(pca9422_handle_t *handle, pca9422_regulator_t reg, bool enable)
2938 {
2939 uint8_t regVal, regAddr, regMask;
2940 bool result;
2941
2942 switch (reg)
2943 {
2944 case kPCA9422_RegulatorSwitch1:
2945 regAddr = PCA9422_REGULATOR_EN;
2946 regVal = (enable == true) ? PCA9422_REGULATOR_EN_B1_ENABLE : 0U;
2947 regMask = PCA9422_REGULATOR_EN_B1_ENABLE;
2948 break;
2949 case kPCA9422_RegulatorSwitch2:
2950 regAddr = PCA9422_REGULATOR_EN;
2951 regVal = (enable == true) ? PCA9422_REGULATOR_EN_B2_ENABLE : 0U;
2952 regMask = PCA9422_REGULATOR_EN_B2_ENABLE;
2953 break;
2954 case kPCA9422_RegulatorSwitch3:
2955 regAddr = PCA9422_REGULATOR_EN;
2956 regVal = (enable == true) ? PCA9422_REGULATOR_EN_B3_ENABLE : 0U;
2957 regMask = PCA9422_REGULATOR_EN_B3_ENABLE;
2958 break;
2959 case kPCA9422_RegulatorSwitch4:
2960 regAddr = PCA9422_SW4_BB_CFG2;
2961 regVal = (enable == true) ? PCA9422_SW4_BB_CFG2_BB_ENABLE : 0U;
2962 regMask = PCA9422_SW4_BB_CFG2_BB_ENABLE;
2963 break;
2964 case kPCA9422_RegulatorLdo1:
2965 LOG_INFO("LDO1-Always ON LDO in Run state\r\n");
2966 regAddr = 0xFFU;
2967 break;
2968 case kPCA9422_RegulatorLdo2:
2969 regAddr = PCA9422_REGULATOR_EN;
2970 regVal = (enable == true) ? PCA9422_REGULATOR_EN_L2_ENABLE : 0U;
2971 regMask = PCA9422_REGULATOR_EN_L2_ENABLE;
2972 break;
2973 case kPCA9422_RegulatorLdo3:
2974 regAddr = PCA9422_REGULATOR_EN;
2975 regVal = (enable == true) ? PCA9422_REGULATOR_EN_L3_ENABLE : 0U;
2976 regMask = PCA9422_REGULATOR_EN_L3_ENABLE;
2977 break;
2978 case kPCA9422_RegulatorLdo4:
2979 regAddr = PCA9422_REGULATOR_EN;
2980 regVal = (enable == true) ? PCA9422_REGULATOR_EN_L4_ENABLE : 0U;
2981 regMask = PCA9422_REGULATOR_EN_L4_ENABLE;
2982 break;
2983 default:
2984 LOG_INFO("Error Invalid regulator\r\n");
2985 regAddr = 0xFFU;
2986 break;
2987 }
2988
2989 if (regAddr != 0xFFU)
2990 {
2991 result = PCA9422_ModifyReg(handle, regAddr, regMask, regVal);
2992 if (result == false)
2993 {
2994 LOG_INFO("Error I2C data write[0x%2X]\r\n", regAddr);
2995 }
2996 }
2997 return;
2998 }
2999
PCA9422_GetEnableRegulatorRunState(pca9422_handle_t * handle,pca9422_regulator_t reg,bool * enable)3000 void PCA9422_GetEnableRegulatorRunState(pca9422_handle_t *handle, pca9422_regulator_t reg, bool *enable)
3001 {
3002 uint8_t regVal, regAddr, regMask;
3003 bool result;
3004
3005 switch (reg)
3006 {
3007 case kPCA9422_RegulatorSwitch1:
3008 regAddr = PCA9422_REGULATOR_EN;
3009 regMask = PCA9422_REGULATOR_EN_B1_ENABLE;
3010 break;
3011 case kPCA9422_RegulatorSwitch2:
3012 regAddr = PCA9422_REGULATOR_EN;
3013 regMask = PCA9422_REGULATOR_EN_B2_ENABLE;
3014 break;
3015 case kPCA9422_RegulatorSwitch3:
3016 regAddr = PCA9422_REGULATOR_EN;
3017 regMask = PCA9422_REGULATOR_EN_B3_ENABLE;
3018 break;
3019 case kPCA9422_RegulatorSwitch4:
3020 regAddr = PCA9422_SW4_BB_CFG2;
3021 regMask = PCA9422_SW4_BB_CFG2_BB_ENABLE;
3022 break;
3023 case kPCA9422_RegulatorLdo1:
3024 /* Always ON LDO in Run state */
3025 regAddr = 0xFFU;
3026 break;
3027 case kPCA9422_RegulatorLdo2:
3028 regAddr = PCA9422_REGULATOR_EN;
3029 regMask = PCA9422_REGULATOR_EN_L2_ENABLE;
3030 break;
3031 case kPCA9422_RegulatorLdo3:
3032 regAddr = PCA9422_REGULATOR_EN;
3033 regMask = PCA9422_REGULATOR_EN_L3_ENABLE;
3034 break;
3035 case kPCA9422_RegulatorLdo4:
3036 regAddr = PCA9422_REGULATOR_EN;
3037 regMask = PCA9422_REGULATOR_EN_L4_ENABLE;
3038 break;
3039 default:
3040 LOG_INFO("Error Invalid regulator\r\n");
3041 regAddr = 0xFFU;
3042 break;
3043 }
3044
3045 if (regAddr != 0xFFU)
3046 {
3047 result = PCA9422_ReadRegs(handle, regAddr, ®Val, 1U);
3048 if (result == false)
3049 {
3050 LOG_INFO("Error I2C data read[0x%2X]\r\n", regAddr);
3051 *enable = false;
3052 }
3053 else
3054 {
3055 regVal = (regVal & regMask);
3056 *enable = (regVal == regMask) ? true : false;
3057 }
3058 }
3059 else
3060 {
3061 if (reg == kPCA9422_RegulatorLdo1)
3062 {
3063 *enable = true;
3064 }
3065 else
3066 {
3067 *enable = false;
3068 }
3069 }
3070
3071 return;
3072 }
3073
PCA9422_ReadPowerModeConfigs(pca9422_handle_t * handle,pca9422_power_mode_t powerMode,pca9422_modecfg_t * configs)3074 void PCA9422_ReadPowerModeConfigs(pca9422_handle_t *handle, pca9422_power_mode_t powerMode, pca9422_modecfg_t *configs)
3075 {
3076 switch (powerMode)
3077 {
3078 case kPCA9422_ActiveModeDVS0:
3079 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch1, kPCA9422_SWDVS0Vout, &configs->sw1OutVolt);
3080 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch2, kPCA9422_SWDVS0Vout, &configs->sw2OutVolt);
3081 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch3, kPCA9422_SWDVS0Vout, &configs->sw3OutVolt);
3082 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch4, kPCA9422_RegVout, &configs->sw4OutVolt);
3083 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorLdo1, kPCA9422_RegVout, &configs->ldo1OutVolt);
3084 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorLdo2, kPCA9422_RegVout, &configs->ldo2OutVolt);
3085 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorLdo3, kPCA9422_RegVout, &configs->ldo3OutVolt);
3086 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorLdo4, kPCA9422_RegVout, &configs->ldo4OutVolt);
3087 break;
3088 case kPCA9422_ActiveModeDVS1:
3089 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch1, kPCA9422_SWDVS1Vout, &configs->sw1OutVolt);
3090 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch2, kPCA9422_SWDVS1Vout, &configs->sw2OutVolt);
3091 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch3, kPCA9422_SWDVS1Vout, &configs->sw3OutVolt);
3092 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch4, kPCA9422_RegVout, &configs->sw4OutVolt);
3093 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorLdo1, kPCA9422_RegVout, &configs->ldo1OutVolt);
3094 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorLdo2, kPCA9422_RegVout, &configs->ldo2OutVolt);
3095 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorLdo3, kPCA9422_RegVout, &configs->ldo3OutVolt);
3096 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorLdo4, kPCA9422_RegVout, &configs->ldo4OutVolt);
3097 break;
3098 case kPCA9422_ActiveModeDVS2:
3099 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch1, kPCA9422_SWDVS2Vout, &configs->sw1OutVolt);
3100 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch2, kPCA9422_SWDVS2Vout, &configs->sw2OutVolt);
3101 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch3, kPCA9422_SWDVS2Vout, &configs->sw3OutVolt);
3102 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch4, kPCA9422_RegVout, &configs->sw4OutVolt);
3103 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorLdo1, kPCA9422_RegVout, &configs->ldo1OutVolt);
3104 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorLdo2, kPCA9422_RegVout, &configs->ldo2OutVolt);
3105 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorLdo3, kPCA9422_RegVout, &configs->ldo3OutVolt);
3106 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorLdo4, kPCA9422_RegVout, &configs->ldo4OutVolt);
3107 break;
3108 case kPCA9422_ActiveModeDVS3:
3109 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch1, kPCA9422_SWDVS3Vout, &configs->sw1OutVolt);
3110 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch2, kPCA9422_SWDVS3Vout, &configs->sw2OutVolt);
3111 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch3, kPCA9422_SWDVS3Vout, &configs->sw3OutVolt);
3112 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch4, kPCA9422_RegVout, &configs->sw4OutVolt);
3113 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorLdo1, kPCA9422_RegVout, &configs->ldo1OutVolt);
3114 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorLdo2, kPCA9422_RegVout, &configs->ldo2OutVolt);
3115 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorLdo3, kPCA9422_RegVout, &configs->ldo3OutVolt);
3116 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorLdo4, kPCA9422_RegVout, &configs->ldo4OutVolt);
3117 break;
3118 case kPCA9422_ActiveModeDVS4:
3119 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch1, kPCA9422_SWDVS4Vout, &configs->sw1OutVolt);
3120 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch2, kPCA9422_SWDVS4Vout, &configs->sw2OutVolt);
3121 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch3, kPCA9422_SWDVS4Vout, &configs->sw3OutVolt);
3122 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch4, kPCA9422_RegVout, &configs->sw4OutVolt);
3123 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorLdo1, kPCA9422_RegVout, &configs->ldo1OutVolt);
3124 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorLdo2, kPCA9422_RegVout, &configs->ldo2OutVolt);
3125 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorLdo3, kPCA9422_RegVout, &configs->ldo3OutVolt);
3126 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorLdo4, kPCA9422_RegVout, &configs->ldo4OutVolt);
3127 break;
3128 case kPCA9422_ActiveModeDVS5:
3129 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch1, kPCA9422_SWDVS5Vout, &configs->sw1OutVolt);
3130 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch2, kPCA9422_SWDVS5Vout, &configs->sw2OutVolt);
3131 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch3, kPCA9422_SWDVS5Vout, &configs->sw3OutVolt);
3132 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch4, kPCA9422_RegVout, &configs->sw4OutVolt);
3133 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorLdo1, kPCA9422_RegVout, &configs->ldo1OutVolt);
3134 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorLdo2, kPCA9422_RegVout, &configs->ldo2OutVolt);
3135 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorLdo3, kPCA9422_RegVout, &configs->ldo3OutVolt);
3136 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorLdo4, kPCA9422_RegVout, &configs->ldo4OutVolt);
3137 break;
3138 case kPCA9422_ActiveModeDVS6:
3139 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch1, kPCA9422_SWDVS6Vout, &configs->sw1OutVolt);
3140 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch2, kPCA9422_SWDVS6Vout, &configs->sw2OutVolt);
3141 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch3, kPCA9422_SWDVS6Vout, &configs->sw3OutVolt);
3142 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch4, kPCA9422_RegVout, &configs->sw4OutVolt);
3143 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorLdo1, kPCA9422_RegVout, &configs->ldo1OutVolt);
3144 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorLdo2, kPCA9422_RegVout, &configs->ldo2OutVolt);
3145 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorLdo3, kPCA9422_RegVout, &configs->ldo3OutVolt);
3146 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorLdo4, kPCA9422_RegVout, &configs->ldo4OutVolt);
3147 break;
3148 case kPCA9422_ActiveModeDVS7:
3149 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch1, kPCA9422_SWDVS7Vout, &configs->sw1OutVolt);
3150 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch2, kPCA9422_SWDVS7Vout, &configs->sw2OutVolt);
3151 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch3, kPCA9422_SWDVS7Vout, &configs->sw3OutVolt);
3152 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch4, kPCA9422_RegVout, &configs->sw4OutVolt);
3153 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorLdo1, kPCA9422_RegVout, &configs->ldo1OutVolt);
3154 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorLdo2, kPCA9422_RegVout, &configs->ldo2OutVolt);
3155 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorLdo3, kPCA9422_RegVout, &configs->ldo3OutVolt);
3156 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorLdo4, kPCA9422_RegVout, &configs->ldo4OutVolt);
3157 break;
3158
3159 case kPCA9422_StandbyMode:
3160 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch1, kPCA9422_RegStandbyVout,
3161 &configs->sw1OutVolt);
3162 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch2, kPCA9422_RegStandbyVout,
3163 &configs->sw2OutVolt);
3164 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch3, kPCA9422_RegStandbyVout,
3165 &configs->sw3OutVolt);
3166 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch4, kPCA9422_RegStandbyVout,
3167 &configs->sw4OutVolt);
3168 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorLdo1, kPCA9422_RegStandbyVout, &configs->ldo1OutVolt);
3169 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorLdo2, kPCA9422_RegStandbyVout, &configs->ldo2OutVolt);
3170 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorLdo3, kPCA9422_RegStandbyVout, &configs->ldo3OutVolt);
3171 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorLdo4, kPCA9422_RegStandbyVout, &configs->ldo4OutVolt);
3172 break;
3173
3174 case kPCA9422_DPStandbyMode:
3175 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch1, kPCA9422_RegStandbyVout,
3176 &configs->sw1OutVolt);
3177 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch2, kPCA9422_RegStandbyVout,
3178 &configs->sw2OutVolt);
3179 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch3, kPCA9422_RegStandbyVout,
3180 &configs->sw3OutVolt);
3181 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch4, kPCA9422_RegStandbyVout,
3182 &configs->sw4OutVolt);
3183 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorLdo1, kPCA9422_RegStandbyVout, &configs->ldo1OutVolt);
3184 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorLdo2, kPCA9422_RegStandbyVout, &configs->ldo2OutVolt);
3185 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorLdo3, kPCA9422_RegStandbyVout, &configs->ldo3OutVolt);
3186 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorLdo4, kPCA9422_RegStandbyVout, &configs->ldo4OutVolt);
3187 break;
3188
3189 case kPCA9422_SleepMode:
3190 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch1, kPCA9422_RegSleepVout, &configs->sw1OutVolt);
3191 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch2, kPCA9422_RegSleepVout, &configs->sw2OutVolt);
3192 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch3, kPCA9422_RegSleepVout, &configs->sw3OutVolt);
3193 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch4, kPCA9422_RegSleepVout, &configs->sw4OutVolt);
3194 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorLdo1, kPCA9422_RegSleepVout, &configs->ldo1OutVolt);
3195 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorLdo2, kPCA9422_RegSleepVout, &configs->ldo2OutVolt);
3196 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorLdo3, kPCA9422_RegSleepVout, &configs->ldo3OutVolt);
3197 PCA9422_GetRegulatorVoltage(handle, kPCA9422_RegulatorLdo4, kPCA9422_RegSleepVout, &configs->ldo4OutVolt);
3198 break;
3199
3200 default:
3201 LOG_INFO("Error - Don't support power mode(%d)\r\n", powerMode);
3202 break;
3203 }
3204 }
3205
PCA9422_WritePowerModeConfigs(pca9422_handle_t * handle,pca9422_power_mode_t powerMode,pca9422_modecfg_t configs)3206 void PCA9422_WritePowerModeConfigs(pca9422_handle_t *handle, pca9422_power_mode_t powerMode, pca9422_modecfg_t configs)
3207 {
3208 switch (powerMode)
3209 {
3210 case kPCA9422_ActiveModeDVS0:
3211 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch1, kPCA9422_SWDVS0Vout, configs.sw1OutVolt);
3212 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch2, kPCA9422_SWDVS0Vout, configs.sw2OutVolt);
3213 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch3, kPCA9422_SWDVS0Vout, configs.sw3OutVolt);
3214 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch4, kPCA9422_RegVout, configs.sw4OutVolt);
3215 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorLdo1, kPCA9422_RegVout, configs.ldo1OutVolt);
3216 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorLdo2, kPCA9422_RegVout, configs.ldo2OutVolt);
3217 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorLdo3, kPCA9422_RegVout, configs.ldo3OutVolt);
3218 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorLdo4, kPCA9422_RegVout, configs.ldo4OutVolt);
3219 break;
3220 case kPCA9422_ActiveModeDVS1:
3221 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch1, kPCA9422_SWDVS1Vout, configs.sw1OutVolt);
3222 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch2, kPCA9422_SWDVS1Vout, configs.sw2OutVolt);
3223 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch3, kPCA9422_SWDVS1Vout, configs.sw3OutVolt);
3224 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch4, kPCA9422_RegVout, configs.sw4OutVolt);
3225 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorLdo1, kPCA9422_RegVout, configs.ldo1OutVolt);
3226 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorLdo2, kPCA9422_RegVout, configs.ldo2OutVolt);
3227 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorLdo3, kPCA9422_RegVout, configs.ldo3OutVolt);
3228 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorLdo4, kPCA9422_RegVout, configs.ldo4OutVolt);
3229 break;
3230 case kPCA9422_ActiveModeDVS2:
3231 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch1, kPCA9422_SWDVS2Vout, configs.sw1OutVolt);
3232 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch2, kPCA9422_SWDVS2Vout, configs.sw2OutVolt);
3233 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch3, kPCA9422_SWDVS2Vout, configs.sw3OutVolt);
3234 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch4, kPCA9422_RegVout, configs.sw4OutVolt);
3235 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorLdo1, kPCA9422_RegVout, configs.ldo1OutVolt);
3236 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorLdo2, kPCA9422_RegVout, configs.ldo2OutVolt);
3237 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorLdo3, kPCA9422_RegVout, configs.ldo3OutVolt);
3238 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorLdo4, kPCA9422_RegVout, configs.ldo4OutVolt);
3239 break;
3240 case kPCA9422_ActiveModeDVS3:
3241 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch1, kPCA9422_SWDVS3Vout, configs.sw1OutVolt);
3242 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch2, kPCA9422_SWDVS3Vout, configs.sw2OutVolt);
3243 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch3, kPCA9422_SWDVS3Vout, configs.sw3OutVolt);
3244 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch4, kPCA9422_RegVout, configs.sw4OutVolt);
3245 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorLdo1, kPCA9422_RegVout, configs.ldo1OutVolt);
3246 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorLdo2, kPCA9422_RegVout, configs.ldo2OutVolt);
3247 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorLdo3, kPCA9422_RegVout, configs.ldo3OutVolt);
3248 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorLdo4, kPCA9422_RegVout, configs.ldo4OutVolt);
3249 break;
3250 case kPCA9422_ActiveModeDVS4:
3251 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch1, kPCA9422_SWDVS4Vout, configs.sw1OutVolt);
3252 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch2, kPCA9422_SWDVS4Vout, configs.sw2OutVolt);
3253 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch3, kPCA9422_SWDVS4Vout, configs.sw3OutVolt);
3254 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch4, kPCA9422_RegVout, configs.sw4OutVolt);
3255 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorLdo1, kPCA9422_RegVout, configs.ldo1OutVolt);
3256 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorLdo2, kPCA9422_RegVout, configs.ldo2OutVolt);
3257 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorLdo3, kPCA9422_RegVout, configs.ldo3OutVolt);
3258 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorLdo4, kPCA9422_RegVout, configs.ldo4OutVolt);
3259 break;
3260 case kPCA9422_ActiveModeDVS5:
3261 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch1, kPCA9422_SWDVS5Vout, configs.sw1OutVolt);
3262 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch2, kPCA9422_SWDVS5Vout, configs.sw2OutVolt);
3263 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch3, kPCA9422_SWDVS5Vout, configs.sw3OutVolt);
3264 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch4, kPCA9422_RegVout, configs.sw4OutVolt);
3265 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorLdo1, kPCA9422_RegVout, configs.ldo1OutVolt);
3266 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorLdo2, kPCA9422_RegVout, configs.ldo2OutVolt);
3267 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorLdo3, kPCA9422_RegVout, configs.ldo3OutVolt);
3268 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorLdo4, kPCA9422_RegVout, configs.ldo4OutVolt);
3269 break;
3270 case kPCA9422_ActiveModeDVS6:
3271 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch1, kPCA9422_SWDVS6Vout, configs.sw1OutVolt);
3272 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch2, kPCA9422_SWDVS6Vout, configs.sw2OutVolt);
3273 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch3, kPCA9422_SWDVS6Vout, configs.sw3OutVolt);
3274 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch4, kPCA9422_RegVout, configs.sw4OutVolt);
3275 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorLdo1, kPCA9422_RegVout, configs.ldo1OutVolt);
3276 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorLdo2, kPCA9422_RegVout, configs.ldo2OutVolt);
3277 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorLdo3, kPCA9422_RegVout, configs.ldo3OutVolt);
3278 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorLdo4, kPCA9422_RegVout, configs.ldo4OutVolt);
3279 break;
3280 case kPCA9422_ActiveModeDVS7:
3281 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch1, kPCA9422_SWDVS7Vout, configs.sw1OutVolt);
3282 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch2, kPCA9422_SWDVS7Vout, configs.sw2OutVolt);
3283 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch3, kPCA9422_SWDVS7Vout, configs.sw3OutVolt);
3284 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch4, kPCA9422_RegVout, configs.sw4OutVolt);
3285 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorLdo1, kPCA9422_RegVout, configs.ldo1OutVolt);
3286 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorLdo2, kPCA9422_RegVout, configs.ldo2OutVolt);
3287 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorLdo3, kPCA9422_RegVout, configs.ldo3OutVolt);
3288 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorLdo4, kPCA9422_RegVout, configs.ldo4OutVolt);
3289 break;
3290
3291 case kPCA9422_StandbyMode:
3292 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch1, kPCA9422_RegStandbyVout, configs.sw1OutVolt);
3293 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch2, kPCA9422_RegStandbyVout, configs.sw2OutVolt);
3294 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch3, kPCA9422_RegStandbyVout, configs.sw3OutVolt);
3295 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch4, kPCA9422_RegStandbyVout, configs.sw4OutVolt);
3296 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorLdo1, kPCA9422_RegStandbyVout, configs.ldo1OutVolt);
3297 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorLdo2, kPCA9422_RegStandbyVout, configs.ldo2OutVolt);
3298 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorLdo3, kPCA9422_RegStandbyVout, configs.ldo3OutVolt);
3299 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorLdo4, kPCA9422_RegStandbyVout, configs.ldo4OutVolt);
3300 break;
3301
3302 case kPCA9422_DPStandbyMode:
3303 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch1, kPCA9422_RegStandbyVout, configs.sw1OutVolt);
3304 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch2, kPCA9422_RegStandbyVout, configs.sw2OutVolt);
3305 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch3, kPCA9422_RegStandbyVout, configs.sw3OutVolt);
3306 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch4, kPCA9422_RegStandbyVout, configs.sw4OutVolt);
3307 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorLdo1, kPCA9422_RegStandbyVout, configs.ldo1OutVolt);
3308 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorLdo2, kPCA9422_RegStandbyVout, configs.ldo2OutVolt);
3309 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorLdo3, kPCA9422_RegStandbyVout, configs.ldo3OutVolt);
3310 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorLdo4, kPCA9422_RegStandbyVout, configs.ldo4OutVolt);
3311 break;
3312
3313 case kPCA9422_SleepMode:
3314 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch1, kPCA9422_RegSleepVout, configs.sw1OutVolt);
3315 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch2, kPCA9422_RegSleepVout, configs.sw2OutVolt);
3316 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch3, kPCA9422_RegSleepVout, configs.sw3OutVolt);
3317 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorSwitch4, kPCA9422_RegSleepVout, configs.sw4OutVolt);
3318 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorLdo1, kPCA9422_RegSleepVout, configs.ldo1OutVolt);
3319 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorLdo2, kPCA9422_RegSleepVout, configs.ldo2OutVolt);
3320 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorLdo3, kPCA9422_RegSleepVout, configs.ldo3OutVolt);
3321 PCA9422_SetRegulatorVoltage(handle, kPCA9422_RegulatorLdo4, kPCA9422_RegSleepVout, configs.ldo4OutVolt);
3322 break;
3323
3324 case kPCA9422_NoneMode:
3325 /* Skip this mode */
3326 LOG_INFO("Skip power mode(%d)\r\n", powerMode);
3327 break;
3328
3329 default:
3330 LOG_INFO("Error - Don't support power mode(%d)\r\n", powerMode);
3331 break;
3332 }
3333 }
3334 /* @} */
3335
PCA9422_WriteEnModeConfig(pca9422_handle_t * handle,pca9422_enmodecfg_t config)3336 void PCA9422_WriteEnModeConfig(pca9422_handle_t *handle, pca9422_enmodecfg_t config)
3337 {
3338 /* Set Enmode */
3339 PCA9422_SetRegulatorEnMode(handle, kPCA9422_RegulatorSwitch1, config.sw1OutEnMode);
3340 PCA9422_SetRegulatorEnMode(handle, kPCA9422_RegulatorSwitch2, config.sw2OutEnMode);
3341 PCA9422_SetRegulatorEnMode(handle, kPCA9422_RegulatorSwitch3, config.sw3OutEnMode);
3342 PCA9422_SetRegulatorEnMode(handle, kPCA9422_RegulatorSwitch4, config.sw4OutEnMode);
3343 PCA9422_SetRegulatorEnMode(handle, kPCA9422_RegulatorLdo1, config.ldo1OutEnMode);
3344 PCA9422_SetRegulatorEnMode(handle, kPCA9422_RegulatorLdo2, config.ldo2OutEnMode);
3345 PCA9422_SetRegulatorEnMode(handle, kPCA9422_RegulatorLdo3, config.ldo3OutEnMode);
3346 PCA9422_SetRegulatorEnMode(handle, kPCA9422_RegulatorLdo4, config.ldo4OutEnMode);
3347 }
3348
PCA9422_WriteRegEnableConfig(pca9422_handle_t * handle,pca9422_regulatoren_t config)3349 void PCA9422_WriteRegEnableConfig(pca9422_handle_t *handle, pca9422_regulatoren_t config)
3350 {
3351 /* Set Enable */
3352 PCA9422_SetEnableRegulatorRunState(handle, kPCA9422_RegulatorSwitch1, config.sw1Enable);
3353 PCA9422_SetEnableRegulatorRunState(handle, kPCA9422_RegulatorSwitch2, config.sw2Enable);
3354 PCA9422_SetEnableRegulatorRunState(handle, kPCA9422_RegulatorSwitch3, config.sw3Enable);
3355 PCA9422_SetEnableRegulatorRunState(handle, kPCA9422_RegulatorSwitch4, config.sw4Enable);
3356 PCA9422_SetEnableRegulatorRunState(handle, kPCA9422_RegulatorLdo1, config.ldo1Enable);
3357 PCA9422_SetEnableRegulatorRunState(handle, kPCA9422_RegulatorLdo2, config.ldo2Enable);
3358 PCA9422_SetEnableRegulatorRunState(handle, kPCA9422_RegulatorLdo3, config.ldo3Enable);
3359 PCA9422_SetEnableRegulatorRunState(handle, kPCA9422_RegulatorLdo4, config.ldo4Enable);
3360 }
3361
PCA9422_EnableState(pca9422_power_mode_t powerMode,pca9422_enmode_t enmode)3362 static bool PCA9422_EnableState(pca9422_power_mode_t powerMode, pca9422_enmode_t enmode)
3363 {
3364 bool enable;
3365
3366 switch (powerMode)
3367 {
3368 case kPCA9422_ActiveModeDVS0 ... kPCA9422_ActiveModeDVS7:
3369 enable = true;
3370 break;
3371 case kPCA9422_StandbyMode:
3372 enable = (enmode < kPCA9422_EnmodeOnActiveSleep) ? true : false;
3373 break;
3374 case kPCA9422_DPStandbyMode:
3375 enable = (enmode < kPCA9422_EnmodeOnActiveSleepStandby) ? true : false;
3376 break;
3377 case kPCA9422_SleepMode:
3378 enable = (enmode < kPCA9422_EnmodeOnActive) ? true : false;
3379 break;
3380 default:
3381 enable = false;
3382 break;
3383 }
3384 return enable;
3385 }
3386
PCA9422_ReadEnableConfigs(pca9422_handle_t * handle,pca9422_power_mode_t powerMode,pca9422_enablecfg_t * config)3387 void PCA9422_ReadEnableConfigs(pca9422_handle_t *handle, pca9422_power_mode_t powerMode, pca9422_enablecfg_t *config)
3388 {
3389 pca9422_enmodecfg_t enmodeCfg;
3390 pca9422_regulatoren_t regenable;
3391
3392 /* Read Enmode */
3393 PCA9422_GetCurrentEnMode(handle, &enmodeCfg);
3394 /* Read Regulator Enable */
3395 PCA9422_GetEnableRegulatorRunState(handle, kPCA9422_RegulatorSwitch1, ®enable.sw1Enable);
3396 PCA9422_GetEnableRegulatorRunState(handle, kPCA9422_RegulatorSwitch2, ®enable.sw2Enable);
3397 PCA9422_GetEnableRegulatorRunState(handle, kPCA9422_RegulatorSwitch3, ®enable.sw3Enable);
3398 PCA9422_GetEnableRegulatorRunState(handle, kPCA9422_RegulatorSwitch4, ®enable.sw4Enable);
3399 PCA9422_GetEnableRegulatorRunState(handle, kPCA9422_RegulatorLdo1, ®enable.ldo1Enable);
3400 PCA9422_GetEnableRegulatorRunState(handle, kPCA9422_RegulatorLdo2, ®enable.ldo2Enable);
3401 PCA9422_GetEnableRegulatorRunState(handle, kPCA9422_RegulatorLdo3, ®enable.ldo3Enable);
3402 PCA9422_GetEnableRegulatorRunState(handle, kPCA9422_RegulatorLdo4, ®enable.ldo4Enable);
3403
3404 /* Check power mode */
3405 switch (powerMode)
3406 {
3407 case kPCA9422_ActiveModeDVS0 ... kPCA9422_ActiveModeDVS7:
3408 config->enableSw1Out = regenable.sw1Enable ? true : false;
3409 config->enableSw2Out = regenable.sw2Enable ? true : false;
3410 config->enableSw3Out = regenable.sw3Enable ? true : false;
3411 config->enableSw4Out = regenable.sw4Enable ? true : false;
3412 config->enableLdo1Out = regenable.ldo1Enable ? true : false;
3413 config->enableLdo2Out = regenable.ldo2Enable ? true : false;
3414 config->enableLdo3Out = regenable.ldo3Enable ? true : false;
3415 config->enableLdo4Out = regenable.ldo4Enable ? true : false;
3416 break;
3417 case kPCA9422_StandbyMode:
3418 case kPCA9422_DPStandbyMode:
3419 case kPCA9422_SleepMode:
3420 config->enableSw1Out = regenable.sw1Enable ? PCA9422_EnableState(powerMode, enmodeCfg.sw1OutEnMode) : false;
3421 config->enableSw2Out = regenable.sw2Enable ? PCA9422_EnableState(powerMode, enmodeCfg.sw2OutEnMode) : false;
3422 config->enableSw3Out = regenable.sw3Enable ? PCA9422_EnableState(powerMode, enmodeCfg.sw3OutEnMode) : false;
3423 config->enableSw4Out = regenable.sw4Enable ? PCA9422_EnableState(powerMode, enmodeCfg.sw4OutEnMode) : false;
3424 config->enableLdo1Out =
3425 regenable.ldo1Enable ? PCA9422_EnableState(powerMode, enmodeCfg.ldo1OutEnMode) : false;
3426 config->enableLdo2Out =
3427 regenable.ldo2Enable ? PCA9422_EnableState(powerMode, enmodeCfg.ldo2OutEnMode) : false;
3428 config->enableLdo3Out =
3429 regenable.ldo3Enable ? PCA9422_EnableState(powerMode, enmodeCfg.ldo3OutEnMode) : false;
3430 config->enableLdo4Out =
3431 regenable.ldo4Enable ? PCA9422_EnableState(powerMode, enmodeCfg.ldo4OutEnMode) : false;
3432 break;
3433 default:
3434 /* Not supported. */
3435 break;
3436 }
3437 }
3438
PCA9422_FeedWatchDog(pca9422_handle_t * handle)3439 void PCA9422_FeedWatchDog(pca9422_handle_t *handle)
3440 {
3441 uint8_t regValue = 1U;
3442
3443 (void)PCA9422_WriteRegs(handle, PCA9422_TOP_CNTL4, ®Value, 1U);
3444 }
3445
PCA9422_SetWatchDogTimer(pca9422_handle_t * handle,pca9422_wd_timer_t wd_timer)3446 void PCA9422_SetWatchDogTimer(pca9422_handle_t *handle, pca9422_wd_timer_t wd_timer)
3447 {
3448 bool result;
3449
3450 result = PCA9422_ModifyReg(handle, PCA9422_TOP_CNTL0, PCA9422_TOP_CNTL0_WD_TIMER, (uint8_t)wd_timer);
3451 if (result == false)
3452 {
3453 LOG_INFO("Error I2C data write[0x%x]\r\n", PCA9422_TOP_CNTL0);
3454 }
3455 }
3456
PCA9422_WriteRegsReadback(pca9422_handle_t * handle,uint8_t regBase,uint8_t * val)3457 bool PCA9422_WriteRegsReadback(pca9422_handle_t *handle, uint8_t regBase, uint8_t *val)
3458 {
3459 bool result;
3460 uint8_t regData;
3461
3462 result = PCA9422_WriteRegs(handle, regBase, val, 1U);
3463 if (result == true)
3464 {
3465 /* Read back */
3466 result = PCA9422_ReadRegs(handle, regBase, ®Data, 1U);
3467 if (result == true)
3468 {
3469 /* Compare data */
3470 if (regData != *val)
3471 {
3472 LOG_INFO("Error I2C data[0x%x] written(0x%x) vs read(0x%x)\r\n", regBase, *val, regData);
3473 result = false;
3474 }
3475 }
3476 else
3477 {
3478 LOG_INFO("Error I2C data read[0x%x]\r\n", regBase);
3479 }
3480 }
3481 else
3482 {
3483 LOG_INFO("Error I2C data write[0x%x]\r\n", regBase);
3484 }
3485 return result;
3486 }
3487
PCA9422_ModifyRegReadback(pca9422_handle_t * handle,uint8_t reg,uint8_t mask,uint8_t val)3488 bool PCA9422_ModifyRegReadback(pca9422_handle_t *handle, uint8_t reg, uint8_t mask, uint8_t val)
3489 {
3490 bool result;
3491 uint8_t regValue = 0U;
3492
3493 assert(handle);
3494
3495 /* Read back the register content. */
3496 result = PCA9422_ReadRegs(handle, reg, ®Value, 1U);
3497 if (result)
3498 {
3499 /* Modify the bit-fields you want to change. */
3500 regValue &= (uint8_t)~mask;
3501 regValue |= val;
3502
3503 /* Write back the content to the registers. */
3504 result = PCA9422_WriteRegsReadback(handle, reg, ®Value);
3505 }
3506
3507 return result;
3508 }
3509
PCA9422_WriteRegs(pca9422_handle_t * handle,uint8_t regBase,uint8_t * val,uint32_t size)3510 bool PCA9422_WriteRegs(pca9422_handle_t *handle, uint8_t regBase, uint8_t *val, uint32_t size)
3511 {
3512 assert(handle);
3513 assert(handle->I2C_SendFunc);
3514 assert(val);
3515
3516 return (kStatus_Success == handle->I2C_SendFunc(handle->slaveAddress, regBase, 1U, val, size)) ? true : false;
3517 }
3518
PCA9422_ReadRegs(pca9422_handle_t * handle,uint8_t regBase,uint8_t * val,uint32_t size)3519 bool PCA9422_ReadRegs(pca9422_handle_t *handle, uint8_t regBase, uint8_t *val, uint32_t size)
3520 {
3521 assert(handle);
3522 assert(handle->I2C_ReceiveFunc);
3523 assert(val);
3524
3525 return (kStatus_Success == handle->I2C_ReceiveFunc(handle->slaveAddress, regBase, 1U, val, size)) ? true : false;
3526 }
3527
PCA9422_ModifyReg(pca9422_handle_t * handle,uint8_t reg,uint8_t mask,uint8_t val)3528 bool PCA9422_ModifyReg(pca9422_handle_t *handle, uint8_t reg, uint8_t mask, uint8_t val)
3529 {
3530 bool result;
3531 uint8_t regValue = 0U;
3532
3533 assert(handle);
3534
3535 /* Read back the register content. */
3536 result = PCA9422_ReadRegs(handle, reg, ®Value, 1U);
3537 if (result)
3538 {
3539 /* Modify the bit-fields you want to change. */
3540 regValue &= (uint8_t)~mask;
3541 regValue |= val;
3542
3543 /* Write back the content to the registers. */
3544 result = PCA9422_WriteRegs(handle, reg, ®Value, 1U);
3545 }
3546
3547 return result;
3548 }
3549
PCA9422_EnableChargerInterrupts(pca9422_handle_t * handle,uint8_t * source)3550 void PCA9422_EnableChargerInterrupts(pca9422_handle_t *handle, uint8_t *source)
3551 {
3552 bool result;
3553 uint8_t maskVal[6];
3554
3555 maskVal[0] = (uint8_t)(~(source[0] & 0xFFU)); /* INT_DEVICE_0_MASK */
3556 maskVal[1] = (uint8_t)(~(source[1] & 0xFFU)); /* INT_DEVICE_1_MASK */
3557 maskVal[2] = (uint8_t)(~(source[2] & 0xFFU)); /* INT_CHARGE_0_MASK */
3558 maskVal[3] = (uint8_t)(~(source[3] & 0xFFU)); /* INT_CHARGE_1_MASK */
3559 maskVal[4] = (uint8_t)(~(source[4] & 0xFFU)); /* INT_CHARGE_2_MASK */
3560 maskVal[5] = (uint8_t)(~(source[5] & 0xFFU)); /* INT_CHARGE_3_MASK */
3561
3562 /* Write mask registers */
3563 result = PCA9422_WriteRegs(handle, PCA9422_INT_DEVICE_0_MASK, maskVal, sizeof(maskVal));
3564 if (!result)
3565 {
3566 LOG_INFO("Error I2C data write interrupt mask registers of charge\r\n");
3567 }
3568 }
3569
PCA9422_DisableChargerInterrupts(pca9422_handle_t * handle,uint8_t * source)3570 void PCA9422_DisableChargerInterrupts(pca9422_handle_t *handle, uint8_t *source)
3571 {
3572 bool result;
3573 uint8_t maskVal[6] = {
3574 0,
3575 };
3576
3577 (void)memcpy(source, maskVal, sizeof(maskVal));
3578
3579 /* Write mask registers */
3580 result = PCA9422_WriteRegs(handle, PCA9422_INT_DEVICE_0_MASK, maskVal, sizeof(maskVal));
3581 if (!result)
3582 {
3583 LOG_INFO("Error I2C data write interrupt mask registers of charge\r\n");
3584 }
3585 }
3586
PCA9422_GetChargerInterrupts(pca9422_handle_t * handle,uint8_t * source)3587 void PCA9422_GetChargerInterrupts(pca9422_handle_t *handle, uint8_t *source)
3588 {
3589 bool result;
3590
3591 /* Read interrupt registers */
3592 result = PCA9422_ReadRegs(handle, PCA9422_INT_DEVICE_0, source, 6U);
3593 if (!result)
3594 {
3595 LOG_INFO("Error I2C data read interrupt registers of charge\r\n");
3596 }
3597 }
3598
PCA9422_GetChargerInterruptStatus(pca9422_handle_t * handle,uint8_t * status)3599 void PCA9422_GetChargerInterruptStatus(pca9422_handle_t *handle, uint8_t *status)
3600 {
3601 bool result;
3602
3603 /* Read interrupt status registers */
3604 result = PCA9422_ReadRegs(handle, PCA9422_DEVICE_0_STS, status, 6U);
3605 if (!result)
3606 {
3607 LOG_INFO("Error I2C data read interrupt status registers of charge\r\n");
3608 }
3609 }
3610
PCA9422_EnableRegulatorInterrupt(pca9422_handle_t * handle,uint8_t * source)3611 void PCA9422_EnableRegulatorInterrupt(pca9422_handle_t *handle, uint8_t *source)
3612 {
3613 bool result;
3614 uint8_t maskVal;
3615
3616 maskVal = (uint8_t)(~(*source & 0xFFU)); /* INT1_MASK */
3617 /* Write mask register */
3618 result = PCA9422_WriteRegs(handle, PCA9422_INT1_MASK, &maskVal, sizeof(maskVal));
3619 if (!result)
3620 {
3621 LOG_INFO("Error I2C data write interrupt mask register of regulator\r\n");
3622 }
3623 }
3624
PCA9422_DisableRegulatorInterrupt(pca9422_handle_t * handle,uint8_t * source)3625 void PCA9422_DisableRegulatorInterrupt(pca9422_handle_t *handle, uint8_t *source)
3626 {
3627 bool result;
3628 uint8_t maskVal = {
3629 0,
3630 };
3631
3632 (void)memcpy(source, &maskVal, sizeof(maskVal));
3633 /* Write mask register */
3634 result = PCA9422_WriteRegs(handle, PCA9422_INT1_MASK, &maskVal, sizeof(maskVal));
3635 if (!result)
3636 {
3637 LOG_INFO("Error I2C data write interrupt mask register of regulator\r\n");
3638 }
3639 }
3640
PCA9422_GetRegulatorInterrupt(pca9422_handle_t * handle,uint8_t * source)3641 void PCA9422_GetRegulatorInterrupt(pca9422_handle_t *handle, uint8_t *source)
3642 {
3643 bool result;
3644
3645 /* Read interrupt register */
3646 result = PCA9422_ReadRegs(handle, PCA9422_INT1, source, 1U);
3647 if (!result)
3648 {
3649 LOG_INFO("Error I2C data read interrupt register of regulator\r\n");
3650 }
3651 }
3652
PCA9422_GetRegulatorInterruptStatus(pca9422_handle_t * handle,uint8_t * status)3653 void PCA9422_GetRegulatorInterruptStatus(pca9422_handle_t *handle, uint8_t *status)
3654 {
3655 bool result;
3656
3657 /* Read interrupt status register */
3658 result = PCA9422_ReadRegs(handle, PCA9422_INT1_STATUS, status, 1U);
3659 if (!result)
3660 {
3661 LOG_INFO("Error I2C data read interrupt status register of regulator\r\n");
3662 }
3663 }
3664
PCA9422_EnableSublevelInterrupts(pca9422_handle_t * handle,uint8_t * source)3665 void PCA9422_EnableSublevelInterrupts(pca9422_handle_t *handle, uint8_t *source)
3666 {
3667 bool result;
3668 uint8_t maskVal[3];
3669
3670 maskVal[0] = (uint8_t)(~(source[0] & 0xFFU)); /* SUB_INT0_MASK */
3671 maskVal[1] = (uint8_t)(~(source[1] & 0xFFU)); /* SUB_INT1_MASK */
3672 maskVal[2] = (uint8_t)(~(source[2] & 0xFFU)); /* SUB_INT2_MASK */
3673
3674 /* Write mask registers */
3675 result = PCA9422_WriteRegs(handle, PCA9422_SUB_INT0_MASK, &maskVal[0], 1U);
3676 if (!result)
3677 {
3678 LOG_INFO("Error I2C data write interrupt mask registers of sub-level\r\n");
3679 }
3680 result = PCA9422_WriteRegs(handle, PCA9422_SUB_INT1_MASK, &maskVal[1], 1U);
3681 if (!result)
3682 {
3683 LOG_INFO("Error I2C data write interrupt mask registers of sub-level\r\n");
3684 }
3685 result = PCA9422_WriteRegs(handle, PCA9422_SUB_INT2_MASK, &maskVal[2], 1U);
3686 if (!result)
3687 {
3688 LOG_INFO("Error I2C data write interrupt mask registers of sub-level\r\n");
3689 }
3690 }
3691
PCA9422_DisableSublevelInterrupts(pca9422_handle_t * handle,uint8_t * source)3692 void PCA9422_DisableSublevelInterrupts(pca9422_handle_t *handle, uint8_t *source)
3693 {
3694 bool result;
3695 uint8_t maskVal[3] = {
3696 0,
3697 };
3698
3699 (void)memcpy(source, maskVal, sizeof(maskVal));
3700 /* Write mask registers */
3701 result = PCA9422_WriteRegs(handle, PCA9422_SUB_INT0_MASK, &maskVal[0], 1U);
3702 if (!result)
3703 {
3704 LOG_INFO("Error I2C data write interrupt mask registers of sub-level\r\n");
3705 }
3706 result = PCA9422_WriteRegs(handle, PCA9422_SUB_INT1_MASK, &maskVal[1], 1U);
3707 if (!result)
3708 {
3709 LOG_INFO("Error I2C data write interrupt mask registers of sub-level\r\n");
3710 }
3711 result = PCA9422_WriteRegs(handle, PCA9422_SUB_INT2_MASK, &maskVal[2], 1U);
3712 if (!result)
3713 {
3714 LOG_INFO("Error I2C data write interrupt mask registers of sub-level\r\n");
3715 }
3716 }
3717
PCA9422_GetSublevelInterrupts(pca9422_handle_t * handle,uint8_t * source)3718 void PCA9422_GetSublevelInterrupts(pca9422_handle_t *handle, uint8_t *source)
3719 {
3720 bool result;
3721
3722 /* Read interrupt registers */
3723 result = PCA9422_ReadRegs(handle, PCA9422_SUB_INT0, &source[0], 1U);
3724 if (!result)
3725 {
3726 LOG_INFO("Error I2C data read interrupt registers of sub-level\r\n");
3727 }
3728 result = PCA9422_ReadRegs(handle, PCA9422_SUB_INT1, &source[1], 1U);
3729 if (!result)
3730 {
3731 LOG_INFO("Error I2C data read interrupt registers of sub-level\r\n");
3732 }
3733 result = PCA9422_ReadRegs(handle, PCA9422_SUB_INT2, &source[2], 1U);
3734 if (!result)
3735 {
3736 LOG_INFO("Error I2C data read interrupt registers of sub-level\r\n");
3737 }
3738 }
3739
PCA9422_GetToplevelInterruptStatus(pca9422_handle_t * handle,uint8_t * status)3740 void PCA9422_GetToplevelInterruptStatus(pca9422_handle_t *handle, uint8_t *status)
3741 {
3742 bool result;
3743
3744 /* Read interrupt registers */
3745 result = PCA9422_ReadRegs(handle, PCA9422_TOP_INT, status, 1U);
3746 if (!result)
3747 {
3748 LOG_INFO("Error I2C data read interrupt registers of top-level\r\n");
3749 }
3750 }
3751 /*******************************************************************************
3752 * EOF
3753 ******************************************************************************/
3754
