1 /**
2 ******************************************************************************
3 * @file lib_LoadNVR.c
4 * @author Application Team
5 * @version V4.7.0
6 * @date 2019-12-12
7 * @brief Load information from NVR.
8 ******************************************************************************
9 * @attention
10 *
11 ******************************************************************************
12 */
13
14 /* Includes ------------------------------------------------------------------*/
15 #include "lib_LoadNVR.h"
16
17
18 /**
19 * @breif Load Analog trim data from NVR manually.
20 * @note Successful Operation:
21 * - Load [0x40DC0] or [0x40DD0] to ANA registers(B C D E), return 0.
22 * Operation failed:
23 * - return 1.
24 * @param None
25 * @retval 0: Function succeeded.
26 1: Function failed(Checksum error).
27 */
NVR_LoadANADataManual(void)28 uint32_t NVR_LoadANADataManual(void)
29 {
30 uint32_t checksum;
31 uint32_t op_reg;
32 uint32_t ana_data;
33 uint32_t key_reg = 0xFFFFFFFF;
34
35 /* Get Analog data1 */
36 ana_data = *NVR_ANA_TRIMDATA1;
37 op_reg = *NVR_ANA_OPREG1;
38 /* Calculate checksum1 */
39 checksum = ~(ana_data + op_reg + key_reg);
40 /* Compare checksum1 */
41 if (checksum == (*NVR_ANA_CHECKSUM1))
42 {
43 ANA->REGB = (uint8_t)(ana_data);
44 ANA->REGC = (uint8_t)(ana_data >> 8);
45 ANA->REGD = (uint8_t)(ana_data >> 16);
46 ANA->REGE = (uint8_t)(ana_data >> 24);
47 return 0;
48 }
49
50 /* Get Analog data2 */
51 ana_data = *NVR_ANA_TRIMDATA2;
52 op_reg = *NVR_ANA_OPREG2;
53 /* Calculate checksum2 */
54 checksum = ~(ana_data + op_reg + key_reg);
55 /* Compare checksum2 */
56 if (checksum == (*NVR_ANA_CHECKSUM2))
57 {
58 ANA->REGB = (uint8_t)(ana_data);
59 ANA->REGC = (uint8_t)(ana_data >> 8);
60 ANA->REGD = (uint8_t)(ana_data >> 16);
61 ANA->REGE = (uint8_t)(ana_data >> 24);
62 return 0;
63 }
64 else
65 {
66 return 1;
67 }
68 }
69
70 /**
71 * @breif Get the parameters of ADC voltage measuring.
72 * @note Voltage(unit:V) = aParameter*ADC_DATA + bParameter
73 * ADC_DATA: ADC channel original data
74 * aParameter/bParameter: Get from this function
75 * @param [in]Mode:
76 * NVR_3V_EXTERNAL_NODIV
77 * NVR_3V_EXTERNAL_RESDIV
78 * NVR_3V_EXTERNAL_CAPDIV
79 * NVR_3V_VDD_RESDIV
80 * NVR_3V_VDD_CAPDIV
81 * NVR_3V_BATRTC_RESDIV
82 * NVR_3V_BATRTC_CAPDIV
83 * NVR_5V_EXTERNAL_NODIV
84 * NVR_5V_EXTERNAL_RESDIV
85 * NVR_5V_EXTERNAL_CAPDIV
86 * NVR_5V_VDD_RESDIV
87 * NVR_5V_VDD_CAPDIV
88 * NVR_5V_BATRTC_RESDIV
89 * NVR_5V_BATRTC_CAPDIV
90 * @param [out]Parameter: The parameters get from NVR
91 * @retval 0: Function succeeded.
92 1: Function failed(Checksum error).
93 */
NVR_GetADCVoltageParameter(uint32_t Mode,NVR_ADCVOLPARA * Parameter)94 uint32_t NVR_GetADCVoltageParameter(uint32_t Mode, NVR_ADCVOLPARA *Parameter)
95 {
96 uint32_t checksum;
97 uint32_t i;
98 int32_t tmp_int;
99
100 /* Check the parameters */
101 assert_parameters(IS_NVR_ADCVOL_MODE(Mode));
102
103 /*----- Power supply: 5V -----*/
104 if (0x100UL & Mode)
105 {
106 checksum = 0UL;
107 for (i=0; i<14; i++)
108 checksum += *(NVR_5VPARA_BASEADDR1+i);
109 checksum = ~(checksum);
110 if (checksum != *(NVR_5VPARA_BASEADDR1+i)) /* Checksum1 error */
111 {
112 checksum = 0UL;
113 for (i=0; i<14; i++)
114 checksum += *(NVR_5VPARA_BASEADDR2+i);
115 checksum = ~(checksum);
116 if (checksum != *(NVR_5VPARA_BASEADDR2+i)) /* Checksum2 error */
117 {
118 return 1;
119 }
120 else
121 {
122 tmp_int = (int32_t)*(NVR_5VPARA_BASEADDR2+2*(Mode-0x100UL));
123 Parameter->aParameter = (float)(tmp_int / 100000000.0);
124 tmp_int = (int32_t)*(NVR_5VPARA_BASEADDR2+2*(Mode-0x100UL)+1);
125 Parameter->bParameter = (float)(tmp_int / 100000000.0);
126 return 0;
127 }
128 }
129 else
130 {
131 tmp_int = (int32_t)*(NVR_5VPARA_BASEADDR1+2*(Mode-0x100UL));
132 Parameter->aParameter = (float)(tmp_int / 100000000.0);
133 tmp_int = (int32_t)*(NVR_5VPARA_BASEADDR1+2*(Mode-0x100UL)+1);
134 Parameter->bParameter = (float)(tmp_int / 100000000.0);
135 return 0;
136 }
137 }
138 /*----- Power supply: 3.3V -----*/
139 else
140 {
141 checksum = 0UL;
142 for (i=0; i<14; i++)
143 checksum += *(NVR_3VPARA_BASEADDR1+i);
144 checksum = ~(checksum);
145 if (checksum != *(NVR_3VPARA_BASEADDR1+i)) /* Checksum1 error */
146 {
147 checksum = 0UL;
148 for (i=0; i<14; i++)
149 checksum += *(NVR_3VPARA_BASEADDR2+i);
150 checksum = ~(checksum);
151 if (checksum != *(NVR_3VPARA_BASEADDR2+i)) /* Checksum2 error */
152 {
153 return 1;
154 }
155 else
156 {
157 tmp_int = (int32_t)*(NVR_3VPARA_BASEADDR2+2*(Mode));
158 Parameter->aParameter = (float)(tmp_int / 100000000.0);
159 tmp_int = (int32_t)*(NVR_3VPARA_BASEADDR2+2*(Mode)+1);
160 Parameter->bParameter = (float)(tmp_int / 100000000.0);
161 return 0;
162 }
163 }
164 else
165 {
166 tmp_int = (int32_t)*(NVR_3VPARA_BASEADDR1+2*(Mode));
167 Parameter->aParameter = (float)(tmp_int / 100000000.0);
168 tmp_int = (int32_t)*(NVR_3VPARA_BASEADDR1+2*(Mode)+1);
169 Parameter->bParameter = (float)(tmp_int / 100000000.0);
170 return 0;
171 }
172 }
173 }
174
175 /**
176 * @breif Get BAT Measure result.
177 * @param [out]MEAResult The pointer to struct NVR_BATMEARES.
178 * @retval 0: Function succeeded.
179 1: Function failed(Checksum error).
180 */
NVR_GetBATOffset(NVR_BATMEARES * MEAResult)181 uint32_t NVR_GetBATOffset(NVR_BATMEARES *MEAResult)
182 {
183 uint32_t bat_r;
184 uint32_t bat_c;
185 uint32_t checksum;
186
187 bat_r = *NVR_BAT_R1;
188 bat_c = *NVR_BAT_C1;
189 /* Calculate checksum1 */
190 checksum = ~(bat_r + bat_c);
191 if (checksum == (*NVR_BATMEA_CHECHSUM1))
192 {
193 MEAResult->BATRESResult = (float)((int32_t)bat_r / 1000.0);
194 MEAResult->BATCAPResult = (float)((int32_t)bat_c / 1000.0);
195 return 0;
196 }
197
198 bat_r = *NVR_BAT_R2;
199 bat_c = *NVR_BAT_C2;
200 /* Calculate checksum2 */
201 checksum = ~(bat_r + bat_c);
202 if (checksum == (*NVR_BATMEA_CHECHSUM2))
203 {
204 MEAResult->BATRESResult = (float)((int32_t)bat_r / 1000.0);
205 MEAResult->BATCAPResult = (float)((int32_t)bat_c / 1000.0);
206 return 0;
207 }
208 else
209 {
210 return 1;
211 }
212 }
213
214 /**
215 * @breif Load RTC ACPx pramameters from NVR to RTC registers.
216 Get RTC pramameters.
217 * @param [out]RTCTempData The pointer to struct NVR_RTCINFO.
218 * @retval 0: Function succeeded.
219 !0: Function not succeeded, load default value to registers.
220 bit[0]=1: Temperature Measure delta information checksum error, default value is 0.
221 bit[1]=1: P paramters checksum error, default value as follows
222 [P0]-214, [P1]1060, [P2]-19746971, [P5]6444, [P6]1342, [P7]0
223 bit[2]=1: P4 checksum error, default value is 0
224 bit[3]=1: ACKx checksum error, default value as follows
225 [K1]20827, [K2]21496, [K3]22020, [K4]24517, [K5]25257
226 bit[4]=1: ACTI checksum error, default value is 0x1800(24.0)
227 bit[5]=1: ACKTEMP checksum error, defalut value is 0x3C2800EC
228 */
NVR_GetInfo_LoadRTCData(NVR_RTCINFO * RTCTempData)229 uint32_t NVR_GetInfo_LoadRTCData(NVR_RTCINFO *RTCTempData)
230 {
231 uint32_t real_temp, mea_temp;
232 uint32_t rtc_data1, rtc_data2, rtc_data3, rtc_data4;
233 uint32_t rtc_p4;
234 uint32_t rtc_ack[5];
235 uint32_t rtc_acti;
236 uint32_t rtc_acktemp;
237 uint32_t checksum;
238 float pclk_mul;
239
240 int16_t TempDelta;
241 uint32_t retval = 0;
242
243 /*------------------------ Temperature Measure delta -------------------------*/
244 real_temp = *NVR_REALTEMP1;
245 mea_temp = *NVR_MEATEMP1;
246 /* Calculate checksum1 */
247 checksum = ~(real_temp + mea_temp);
248 if (checksum == (*NVR_TEMP_CHECKSUM1)) //checksum1 true
249 {
250 TempDelta = (int16_t)real_temp - (int16_t)mea_temp;
251 }
252 else
253 {
254 real_temp = *NVR_REALTEMP2;
255 mea_temp = *NVR_MEATEMP2;
256 /* Calculate checksum2 */
257 checksum = ~(real_temp + mea_temp);
258 if (checksum == (*NVR_TEMP_CHECKSUM2)) //checksum2 true
259 {
260 TempDelta = (int16_t)real_temp - (int16_t)mea_temp;
261 }
262 else
263 {
264 TempDelta = 0;
265 retval |= BIT0;
266 }
267 }
268 /* Get Measure delta information */
269 RTCTempData->RTCTempDelta = TempDelta;
270
271 /*------------------------------ P parameters --------------------------------*/
272 /* Wait until the RTC registers be synchronized */
273 RTC_WaitForSynchro();
274 /* Disable RTC Registers write-protection */
275 RTC_WriteProtection(DISABLE);
276
277 /* Get PCLK */
278 RTCTempData->APBClock = CLK_GetPCLKFreq();
279 pclk_mul = RTCTempData->APBClock / 6553600.0;
280
281 rtc_data1 = *NVR_RTC1_P1_P0;
282 rtc_data2 = *NVR_RTC1_P2;
283 rtc_data3 = *NVR_RTC1_P5_P4;
284 rtc_data4 = *NVR_RTC1_P7_P6;
285 /* Calculate checksum1 */
286 checksum = ~(rtc_data1 + rtc_data2 + rtc_data3 + rtc_data4);
287 if (checksum == (*NVR_RTC1_PCHECHSUM)) //checksum1 true
288 {
289 /* Get information */
290 RTCTempData->RTCTempP0 = (int16_t)(rtc_data1);
291 RTCTempData->RTCTempP1 = (int16_t)(rtc_data1 >> 16);
292 RTCTempData->RTCTempP2 = (int32_t)((int32_t)rtc_data2 + (((int32_t)TempDelta)*256));
293 RTCTempData->RTCTempP5 = (int16_t)(rtc_data3 >> 16);
294 RTCTempData->RTCTempP6 = (int16_t)(rtc_data4 * pclk_mul);
295 RTCTempData->RTCTempP7 = (int16_t)(rtc_data4 >> 16);
296
297 /* Load data to ACPx register */
298 RTC->ACP0 = (uint16_t)(rtc_data1 & 0xFFFF);
299 RTC->ACP1 = (uint16_t)((rtc_data1 >> 16) & 0xFFFF);
300 RTC->ACP2 = (uint32_t)((int32_t)rtc_data2 + (((int32_t)TempDelta)*256));
301 RTC->ACP5 = (uint16_t)((rtc_data3 >> 16) & 0xFFFF);
302 RTC->ACP6 = (uint16_t)((int16_t)(rtc_data4 * pclk_mul));
303 RTC->ACP7 = (uint16_t)((rtc_data4 >> 16) & 0xFFFF);
304 }
305 else
306 {
307 rtc_data1 = *NVR_RTC2_P1_P0;
308 rtc_data2 = *NVR_RTC2_P2;
309 rtc_data3 = *NVR_RTC2_P5_P4;
310 rtc_data4 = *NVR_RTC2_P7_P6;
311 /* Calculate checksum2 */
312 checksum = ~(rtc_data1 + rtc_data2 + rtc_data3 + rtc_data4);
313 if (checksum == (*NVR_RTC2_PCHECHSUM)) //checksum2 true
314 {
315 /* Get information */
316 RTCTempData->RTCTempP0 = (int16_t)(rtc_data1);
317 RTCTempData->RTCTempP1 = (int16_t)(rtc_data1 >> 16);
318 RTCTempData->RTCTempP2 = (int32_t)((int32_t)rtc_data2 + (((int32_t)TempDelta)*256));
319 RTCTempData->RTCTempP5 = (int16_t)(rtc_data3 >> 16);
320 RTCTempData->RTCTempP6 = (int16_t)(rtc_data4 * pclk_mul);
321 RTCTempData->RTCTempP7 = (int16_t)(rtc_data4 >> 16);
322
323 /* Load data to ACPx register */
324 RTC->ACP0 = (uint16_t)(rtc_data1 & 0xFFFF);
325 RTC->ACP1 = (uint16_t)((rtc_data1 >> 16) & 0xFFFF);
326 RTC->ACP2 = (uint32_t)((int32_t)rtc_data2 + (((int32_t)TempDelta)*256));
327 RTC->ACP5 = (uint16_t)((rtc_data3 >> 16) & 0xFFFF);
328 RTC->ACP6 = (uint16_t)((int16_t)(rtc_data4 * pclk_mul));
329 RTC->ACP7 = (uint16_t)((rtc_data4 >> 16) & 0xFFFF);
330 }
331 else
332 {
333 /* Get information */
334 RTCTempData->RTCTempP0 = -214;
335 RTCTempData->RTCTempP1 = 1060;
336 RTCTempData->RTCTempP2 = -19746971 + (TempDelta*256);
337 RTCTempData->RTCTempP5 = 6444;
338 RTCTempData->RTCTempP6 = (uint32_t)((int32_t)(1342*pclk_mul));
339 RTCTempData->RTCTempP7 = 0;
340
341 /* Load data to ACPx register */
342 RTC->ACP0 = (uint16_t)(-214);
343 RTC->ACP1 = (uint16_t)(1060);
344 RTC->ACP2 = (uint32_t)(-19746971 + (TempDelta*256));
345 RTC->ACP5 = (uint16_t)(6444);
346 RTC->ACP6 = (uint16_t)((int32_t)(1342*pclk_mul));
347 RTC->ACP7 = (uint16_t)(0);
348
349 retval |= BIT1;
350 }
351 }
352
353 /*----------------------------------- P4 -------------------------------------*/
354 /* Calculate checksum1 */
355 rtc_p4 = *NVR_RTC1_P4;
356 checksum = ~rtc_p4;
357 if (checksum == (*NVR_RTC1_P4_CHKSUM))//checksum1 true
358 {
359 /* Get information */
360 RTCTempData->RTCTempP4 = (int16_t)(*NVR_RTC1_P4);
361 RTC->ACP4 = *NVR_RTC1_P4;
362 }
363 else
364 {
365 rtc_p4 = *NVR_RTC2_P4;
366 checksum = ~rtc_p4;
367 if (checksum == (*NVR_RTC2_P4_CHKSUM))//checksum2 true
368 {
369 /* Get information */
370 RTCTempData->RTCTempP4 = (int16_t)(*NVR_RTC1_P4);
371 RTC->ACP4 = *NVR_RTC1_P4;
372 }
373 else
374 {
375 RTCTempData->RTCTempP4 = 0;
376 RTC->ACP4 = 0;
377
378 retval |= BIT2;
379 }
380 }
381
382 /*-------------------------- RTC ACKx parameters -----------------------------*/
383 rtc_ack[0] = *NVR_RTC1_ACK1;
384 rtc_ack[1] = *NVR_RTC1_ACK2;
385 rtc_ack[2] = *NVR_RTC1_ACK3;
386 rtc_ack[3] = *NVR_RTC1_ACK4;
387 rtc_ack[4] = *NVR_RTC1_ACK5;
388 checksum = ~(rtc_ack[0] + rtc_ack[1] + rtc_ack[2] + rtc_ack[3] + rtc_ack[4]);
389 if (checksum == (*NVR_RTC1_ACK_CHKSUM))//checksum1 true
390 {
391 /* Get information */
392 RTCTempData->RTCTempK1 = rtc_ack[0];
393 RTCTempData->RTCTempK2 = rtc_ack[1];
394 RTCTempData->RTCTempK3 = rtc_ack[2];
395 RTCTempData->RTCTempK4 = rtc_ack[3];
396 RTCTempData->RTCTempK5 = rtc_ack[4];
397
398 /* Load data to ACKx register */
399 RTC->ACK1 = rtc_ack[0];
400 RTC->ACK2 = rtc_ack[1];
401 RTC->ACK3 = rtc_ack[2];
402 RTC->ACK4 = rtc_ack[3];
403 RTC->ACK5 = rtc_ack[4];
404 }
405 else
406 {
407 rtc_ack[0] = *NVR_RTC2_ACK1;
408 rtc_ack[1] = *NVR_RTC2_ACK2;
409 rtc_ack[2] = *NVR_RTC2_ACK3;
410 rtc_ack[3] = *NVR_RTC2_ACK4;
411 rtc_ack[4] = *NVR_RTC2_ACK5;
412 checksum = ~(rtc_ack[0] + rtc_ack[1] + rtc_ack[2] + rtc_ack[3] + rtc_ack[4]);
413 if (checksum == (*NVR_RTC2_ACK_CHKSUM))//checksum2 true
414 {
415 /* Get information */
416 RTCTempData->RTCTempK1 = rtc_ack[0];
417 RTCTempData->RTCTempK2 = rtc_ack[1];
418 RTCTempData->RTCTempK3 = rtc_ack[2];
419 RTCTempData->RTCTempK4 = rtc_ack[3];
420 RTCTempData->RTCTempK5 = rtc_ack[4];
421
422 /* Load data to ACKx register */
423 RTC->ACK1 = rtc_ack[0];
424 RTC->ACK2 = rtc_ack[1];
425 RTC->ACK3 = rtc_ack[2];
426 RTC->ACK4 = rtc_ack[3];
427 RTC->ACK5 = rtc_ack[4];
428 }
429 else
430 {
431 /* Get information */
432 RTCTempData->RTCTempK1 = 20827;
433 RTCTempData->RTCTempK2 = 21496;
434 RTCTempData->RTCTempK3 = 22020;
435 RTCTempData->RTCTempK4 = 24517;
436 RTCTempData->RTCTempK5 = 25257;
437
438 /* Load data to ACKx register */
439 RTC->ACK1 = 20827;
440 RTC->ACK2 = 21496;
441 RTC->ACK3 = 22020;
442 RTC->ACK4 = 24517;
443 RTC->ACK5 = 25257;
444
445 retval |= BIT3;
446 }
447 }
448
449 /*-------------------------- RTC ACTI parameters -----------------------------*/
450 rtc_acti = *NVR_RTC1_ACTI;
451 checksum = ~rtc_acti;
452 if (checksum == (*NVR_RTC1_ACTI_CHKSUM))
453 {
454 /* Get information */
455 RTCTempData->RTCACTI = rtc_acti;
456 /* Load data to ACKx register */
457 RTC->ACTI = rtc_acti;
458 }
459 else
460 {
461 rtc_acti = *NVR_RTC2_ACTI;
462 checksum = ~rtc_acti;
463 if (checksum == (*NVR_RTC2_ACTI_CHKSUM))
464 {
465 /* Get information */
466 RTCTempData->RTCACTI = rtc_acti;
467 /* Load data to ACKx register */
468 RTC->ACTI = rtc_acti;
469 }
470 else
471 {
472 /* Get information */
473 RTCTempData->RTCACTI = 0x1800;
474 RTC->ACTI = 0x1800;
475
476 retval |= BIT4;
477 }
478 }
479
480 /*------------------------- RTC ACKTemp parameters ---------------------------*/
481 rtc_acktemp = *NVR_RTC1_ACKTEMP;
482 checksum = ~rtc_acktemp;
483 if (checksum == (*NVR_RTC1_ACKTEMP_CHKSUM))
484 {
485 /* Get information */
486 RTCTempData->RTCACKTemp = rtc_acktemp;
487 /* Load data to ACKx register */
488 RTC->ACKTEMP = rtc_acktemp;
489 }
490 else
491 {
492 rtc_acktemp = *NVR_RTC2_ACKTEMP;
493 checksum = ~rtc_acktemp;
494 if (checksum == (*NVR_RTC2_ACKTEMP_CHKSUM))
495 {
496 /* Get information */
497 RTCTempData->RTCACKTemp = rtc_acktemp;
498 /* Load data to ACKx register */
499 RTC->ACKTEMP = rtc_acktemp;
500 }
501 else
502 {
503 /* Get information */
504 RTCTempData->RTCACKTemp = 0x3C2800EC;
505 RTC->ACKTEMP = 0x3C2800EC;
506
507 retval |= BIT5;
508 }
509 }
510 /*--------------------------------- ACF200 -----------------------------------*/
511 RTCTempData->RTCACF200 = (uint32_t)((int32_t)(pclk_mul*0x320000));
512 RTC->ACF200 = (uint32_t)((int32_t)(pclk_mul*0x320000));
513
514 /* Enable RTC Registers write-protection */
515 RTC_WriteProtection(ENABLE);
516 /* Wait until the RTC registers be synchronized */
517 RTC_WaitForSynchro();
518
519 return retval;
520 }
521
522 /**
523 * @breif Get Power/Clock Measure result.
524 * @param [out]MEAResult The pointer to struct NVR_PWRMEARES.
525 * @retval 0: Function succeeded.
526 1: Function failed(Checksum error).
527 */
NVR_GetMISCGain(NVR_MISCGain * MEAResult)528 uint32_t NVR_GetMISCGain(NVR_MISCGain *MEAResult)
529 {
530 uint32_t avcc_data, dvcc_data, bgp_data, rcl_data, rch_data;
531 uint32_t checksum;
532
533 avcc_data = *NVR_AVCC_MEA1;
534 dvcc_data = *NVR_DVCC_MEA1;
535 bgp_data = *NVR_BGP_MEA1;
536 rcl_data = *NVR_RCL_MEA1;
537 rch_data = *NVR_RCH_MEA1;
538 /* Calculate checksum1 */
539 checksum = ~(avcc_data + dvcc_data + bgp_data + rcl_data + rch_data);
540 if (checksum == (*NVR_PWR_CHECKSUM1))
541 {
542 MEAResult->AVCCMEAResult = avcc_data;
543 MEAResult->DVCCMEAResult = dvcc_data;
544 MEAResult->BGPMEAResult = bgp_data;
545 MEAResult->RCLMEAResult = rcl_data;
546 MEAResult->RCHMEAResult = rch_data;
547 return 0;
548 }
549
550 avcc_data = *NVR_AVCC_MEA2;
551 dvcc_data = *NVR_DVCC_MEA2;
552 bgp_data = *NVR_BGP_MEA2;
553 rcl_data = *NVR_RCL_MEA2;
554 rch_data = *NVR_RCH_MEA2;
555 /* Calculate checksum2 */
556 checksum = ~(avcc_data + dvcc_data + bgp_data + rcl_data + rch_data);
557 if (checksum == (*NVR_PWR_CHECKSUM2))
558 {
559 MEAResult->AVCCMEAResult = avcc_data;
560 MEAResult->DVCCMEAResult = dvcc_data;
561 MEAResult->BGPMEAResult = bgp_data;
562 MEAResult->RCLMEAResult = rcl_data;
563 MEAResult->RCHMEAResult = rch_data;
564 return 0;
565 }
566 else
567 {
568 return 1;
569 }
570 }
571
572 /**
573 * @breif Get Chip ID.
574 * @param [out]ChipID The pointer to struct NVR_CHIPID.
575 * @retval 0: Function succeeded.
576 1: Function failed(Checksum error).
577 */
NVR_GetChipID(NVR_CHIPID * ChipID)578 uint32_t NVR_GetChipID(NVR_CHIPID *ChipID)
579 {
580 uint32_t id0, id1;
581 uint32_t checksum;
582
583 id0 = *NVR_CHIP1_ID0;
584 id1 = *NVR_CHIP1_ID1;
585 /* Calculate checksum1 */
586 checksum = ~(id0 + id1);
587 if (checksum == (*NVR_CHIP1_CHECKSUM))
588 {
589 ChipID->ChipID0 = id0;
590 ChipID->ChipID1 = id1;
591 return 0;
592 }
593
594 id0 = *NVR_CHIP2_ID0;
595 id1 = *NVR_CHIP2_ID1;
596 /* Calculate checksum2 */
597 checksum = ~(id0 + id1);
598 if (checksum == (*NVR_CHIP2_CHECKSUM))
599 {
600 ChipID->ChipID0 = id0;
601 ChipID->ChipID1 = id1;
602 return 0;
603 }
604 else
605 {
606 return 1;
607 }
608 }
609
610 /**
611 * @breif Get LCD information.
612 * @param [out]LCDInfo The pointer to struct NVR_LCDINFO.
613 * @retval 0: Function succeeded.
614 1: Function failed(Checksum error).
615 */
NVR_GetLCDInfo(NVR_LCDINFO * LCDInfo)616 uint32_t NVR_GetLCDInfo(NVR_LCDINFO *LCDInfo)
617 {
618 uint32_t lcd_ldo, lcd_vol;
619 uint32_t checksum;
620
621 lcd_ldo = *NVR_LCD_LDO1;
622 lcd_vol = *NVR_LCD_VOL1;
623 /* Calculate checksum1 */
624 checksum = ~(lcd_ldo + lcd_vol);
625 if (checksum == (*NVR_LCD_CHECKSUM1))
626 {
627 LCDInfo->MEALCDLDO = lcd_ldo;
628 LCDInfo->MEALCDVol = lcd_vol;
629 return 0;
630 }
631
632 lcd_ldo = *NVR_LCD_LDO2;
633 lcd_vol = *NVR_LCD_VOL2;
634 /* Calculate checksum2 */
635 checksum = ~(lcd_ldo + lcd_vol);
636 if (checksum == (*NVR_LCD_CHECKSUM2))
637 {
638 LCDInfo->MEALCDLDO = lcd_ldo;
639 LCDInfo->MEALCDVol = lcd_vol;
640 return 0;
641 }
642 else
643 {
644 return 1;
645 }
646 }
647
648 /*********************************** END OF FILE ******************************/
649