1 /*
2 * Copyright (C) 2015-2017 Alibaba Group Holding Limited
3 *
4 *
5 */
6
7 #include <stdio.h>
8 #include <stdlib.h>
9 #include <string.h>
10 #include "aos/kernel.h"
11 #include "sensor_drv_api.h"
12 #include "sensor_hal.h"
13
14
15
16 #define ADPD188GG_I2C_ADDR1 (0x64)
17 #define ADPD188GG_I2C_ADDR_TRANS(n) ((n)<<1)
18 #define ADPD188GG_I2C_ADDR ADPD188GG_I2C_ADDR_TRANS(ADPD188GG_I2C_ADDR1)
19
20 #define ADPD188GG_STATUS 0x00
21 #define ADPD188GG_INT_MASK 0x01
22 #define ADPD188GG_FIFOTHRESH 0x06
23 #define ADPD188GG_DEVID 0x08
24 #define ADPD188GG_SW_RESET 0x0F
25 #define ADPD188GG_MODE 0x10
26 #define ADPD188GG_SLOT_EN 0x11
27 #define ADPD188GG_FSAMPLE 0x12
28 #define ADPD188GG_PDLED_SEL 0x14
29 #define ADPD188GG_NUM_AVG 0x15
30 #define ADPD188GG_SLOTA_CH1_OFFSET 0x18
31 #define ADPD188GG_SLOTA_CH2_OFFSET 0x19
32 #define ADPD188GG_SLOTA_CH3_OFFSET 0x1A
33 #define ADPD188GG_SLOTA_CH4_OFFSET 0x1B
34 #define ADPD188GG_SLOTB_CH1_OFFSET 0x1E
35 #define ADPD188GG_SLOTB_CH2_OFFSET 0x1F
36 #define ADPD188GG_SLOTB_CH3_OFFSET 0x20
37 #define ADPD188GG_SLOTB_CH4_OFFSET 0x21
38 #define ADPD188GG_LED3_COARSE 0x22
39 #define ADPD188GG_LED1_COARSE 0x23
40 #define ADPD188GG_LED2_COARSE 0x24
41 #define ADPD188GG_LED_FINE 0x25
42 #define ADPD188GG_SLOTA_LED_PULSE 0x30
43 #define ADPD188GG_SLOTA_NUMPULSES 0x31
44 #define ADPD188GG_LED_DISABLE 0x34
45 #define ADPD188GG_SLOTB_LED_PULSE 0x35
46 #define ADPD188GG_SLOTB_NUMPULSES 0x36
47 #define ADPD188GG_SLOTA_AFE_WINDOW 0x39
48 #define ADPD188GG_SLOTB_AFE_WINDOW 0x3B
49 #define ADPD188GG_AFE_POWER_CFG1 0x3C
50 #define ADPD188GG_SLOTB_FLOAT_LED 0x3F
51 #define ADPD188GG_SLOTA_TIA_CFG 0x42
52 #define ADPD188GG_SLOTA_AFE_CFG 0x43
53 #define ADPD188GG_SLOTB_TIA_CFG 0x44
54 #define ADPD188GG_SLOTB_AFE_CFG 0x45
55 #define ADPD188GG_SAMPLE_CLOCK 0x4B
56 #define ADPD188GG_CLK32_ADJUST 0x4D
57 #define ADPD188GG_XXXX 0x4E
58 #define ADPD188GG_AFE_POWER_CFG2 0x54
59 #define ADPD188GG_MATH 0x58
60 #define ADPD188GG_FLT_CONGIG_B 0x59
61 #define ADPD188GG_FLT_LED_FIRE 0x5A
62 #define ADPD188GG_FIFO_ACCESS 0x60
63
64 #define ADPD188GG_MEASURE_MODE 0x02
65 #define ADPD188GG_STAND_BY_MODE 0x00
66 #define ADPD188GG_DEVICE_ID_VALUE 0x160A
67 #define ADPD188GG_SOFT_RESET_VALUE 0x01
68 #define ADPD188GG_DEFAULT_ODR_100HZ 20
69
70 i2c_dev_t adpd188gg_ctx = {
71 .port = 3,
72 .config.address_width = 8,
73 .config.freq = 400000,
74 .config.dev_addr = ADPD188GG_I2C_ADDR,
75 };
76
drv_ecg_adi_adpd188gg_validate_id(i2c_dev_t * drv,uint16_t id_value)77 static int drv_ecg_adi_adpd188gg_validate_id(i2c_dev_t* drv, uint16_t id_value)
78 {
79 uint16_t value;
80 int ret = 0;
81
82 if(drv == NULL){
83 return -1;
84 }
85
86 ret = sensor_i2c_read(drv, ADPD188GG_DEVID, (uint8_t *)(&value), I2C_DATA_LEN*2, I2C_OP_RETRIES);
87 if(unlikely(ret)){
88 return -1;
89 }
90
91 if (id_value != value){
92 return -1;
93 }
94
95 return 0;
96 }
97
drv_ecg_adi_adpd188gg_soft_reset(i2c_dev_t * drv)98 static int drv_ecg_adi_adpd188gg_soft_reset(i2c_dev_t* drv)
99 {
100 int ret = 0;
101 uint8_t value[2] = {0x00, ADPD188GG_SOFT_RESET_VALUE};
102
103 ret = sensor_i2c_write(drv, ADPD188GG_SW_RESET, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
104 if(unlikely(ret)){
105 return ret;
106 }
107 return 0;
108 }
109
drv_ecg_adi_adpd188gg_set_power_mode(i2c_dev_t * drv,dev_power_mode_e mode)110 static int drv_ecg_adi_adpd188gg_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
111 {
112 uint8_t value[2];
113 int ret = 0;
114
115 ret = sensor_i2c_read(drv, ADPD188GG_MODE, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
116 if(unlikely(ret)){
117 return ret;
118 }
119
120 switch(mode){
121 case DEV_POWER_ON:{
122 value[0]= 0x00;
123 value[1]= ADPD188GG_MEASURE_MODE;
124 ret = sensor_i2c_write(drv, ADPD188GG_MODE, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
125 if(unlikely(ret)){
126 return ret;
127 }
128 }break;
129
130 case DEV_POWER_OFF:{
131 value[0] = 0x00;
132 value[1] = ADPD188GG_STAND_BY_MODE;
133 ret = sensor_i2c_write(drv, ADPD188GG_MODE, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
134 if(unlikely(ret)){
135 return ret;
136 }
137 }break;
138
139 default:break;
140 }
141 return 0;
142 }
143
drv_ecg_adi_adpd188gg_set_odr(i2c_dev_t * drv,uint16_t odr)144 static int drv_ecg_adi_adpd188gg_set_odr(i2c_dev_t* drv, uint16_t odr)
145 {
146 int ret = 0;
147 uint8_t value[2];
148 uint16_t odr_val = 2000 / odr;
149
150 value[0] = (uint8_t) ((odr_val & 0xFF00)>>8);
151 value[1] = (uint8_t) (odr_val & 0x00FF);
152
153 ret = sensor_i2c_write(drv, ADPD188GG_FSAMPLE, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
154 if(unlikely(ret)){
155 return ret;
156 }
157
158 value[0] = 0x09, value[1] = 0x00;
159 ret = sensor_i2c_write(drv, ADPD188GG_FIFOTHRESH, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
160 if(unlikely(ret)){
161 return ret;
162 }
163
164 value[0] = 0x02, value[1] = 0x20;
165 ret = sensor_i2c_write(drv, ADPD188GG_NUM_AVG, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
166 if(unlikely(ret)){
167 return ret;
168 }
169
170 return 0;
171 }
172
drv_ecg_adi_adpd188gg_set_offset(i2c_dev_t * drv)173 static int drv_ecg_adi_adpd188gg_set_offset(i2c_dev_t* drv)
174 {
175 int ret = 0;
176 uint8_t value[2];
177
178 value[0] = 0x30, value[1] = 0x60;
179 ret = sensor_i2c_write(drv, ADPD188GG_SLOT_EN, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
180 if(unlikely(ret)){
181 return ret;
182 }
183
184 value[0] = 0x01, value[1] = 0x14;
185 ret = sensor_i2c_write(drv, ADPD188GG_PDLED_SEL, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
186 if(unlikely(ret)){
187 return ret;
188 }
189
190 //SLOT_A_OFFSET
191 value[0] = 0x1F, value[1] = 0x80;
192 ret = sensor_i2c_write(drv, ADPD188GG_SLOTA_CH1_OFFSET, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
193 if(unlikely(ret)){
194 return ret;
195 }
196 value[0] = 0x3F, value[1] = 0xFF;
197 ret = sensor_i2c_write(drv, ADPD188GG_SLOTA_CH2_OFFSET, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
198 if(unlikely(ret)){
199 return ret;
200 }
201 value[0] = 0x3F, value[1] = 0xFF;
202 ret = sensor_i2c_write(drv, ADPD188GG_SLOTA_CH3_OFFSET, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
203 if(unlikely(ret)){
204 return ret;
205 }
206 value[0] = 0x3F, value[1] = 0xFF;
207 ret = sensor_i2c_write(drv, ADPD188GG_SLOTA_CH4_OFFSET, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
208 if(unlikely(ret)){
209 return ret;
210 }
211 //SLOT_B_OFFSET
212 value[0] = 0x1F, value[1] = 0x80;
213 ret = sensor_i2c_write(drv, ADPD188GG_SLOTB_CH1_OFFSET, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
214 if(unlikely(ret)){
215 return ret;
216 }
217 value[0] = 0x3F, value[1] = 0xFF;
218 ret = sensor_i2c_write(drv, ADPD188GG_SLOTB_CH2_OFFSET, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
219 if(unlikely(ret)){
220 return ret;
221 }
222 value[0] = 0x3F, value[1] = 0xFF;
223 ret = sensor_i2c_write(drv, ADPD188GG_SLOTB_CH3_OFFSET, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
224 if(unlikely(ret)){
225 return ret;
226 }
227 value[0] = 0x3F, value[1] = 0xFF;
228 ret = sensor_i2c_write(drv, ADPD188GG_SLOTB_CH4_OFFSET, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
229 if(unlikely(ret)){
230 return ret;
231 }
232
233 return 0;
234 }
235
drv_ecg_adi_adpd188gg_set_led_coarse(i2c_dev_t * drv)236 static int drv_ecg_adi_adpd188gg_set_led_coarse(i2c_dev_t* drv)
237 {
238 int ret = 0;
239 uint8_t value[2];
240
241 value[0] = 0x10, value[1] = 0x33;
242 ret = sensor_i2c_write(drv, ADPD188GG_LED3_COARSE, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
243 if(unlikely(ret)){
244 return ret;
245 }
246
247 value[0] = 0x10, value[1] = 0x3e;
248 ret = sensor_i2c_write(drv, ADPD188GG_LED1_COARSE, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
249 if(unlikely(ret)){
250 return ret;
251 }
252
253 value[0] = 0x10, value[1] = 0x30;
254 ret = sensor_i2c_write(drv, ADPD188GG_LED2_COARSE, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
255 if(unlikely(ret)){
256 return ret;
257 }
258
259 value[0] = 0x63, value[1] = 0x0F;
260 ret = sensor_i2c_write(drv, ADPD188GG_LED_FINE, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
261 if(unlikely(ret)){
262 return ret;
263 }
264
265 return 0;
266 }
267
drv_ecg_adi_adpd188gg_set_led(i2c_dev_t * drv)268 static int drv_ecg_adi_adpd188gg_set_led(i2c_dev_t* drv)
269 {
270 int ret = 0;
271 uint8_t value[2];
272
273 value[0] = 0x03, value[1] = 0x19;
274 ret = sensor_i2c_write(drv, ADPD188GG_SLOTA_LED_PULSE, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
275 if(unlikely(ret)){
276 return ret;
277 }
278
279 value[0] = 0x01, value[1] = 0x0B;
280 ret = sensor_i2c_write(drv, ADPD188GG_SLOTA_NUMPULSES, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
281 if(unlikely(ret)){
282 return ret;
283 }
284
285 value[0] = 0x01, value[1] = 0x00;
286 ret = sensor_i2c_write(drv, ADPD188GG_LED_DISABLE, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
287 if(unlikely(ret)){
288 return ret;
289 }
290
291 value[0] = 0x03, value[1] = 0x19;
292 ret = sensor_i2c_write(drv, ADPD188GG_SLOTB_LED_PULSE, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
293 if(unlikely(ret)){
294 return ret;
295 }
296
297 value[0] = 0x08, value[1] = 0x0B;
298 ret = sensor_i2c_write(drv, ADPD188GG_SLOTB_NUMPULSES, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
299 if(unlikely(ret)){
300 return ret;
301 }
302
303 return 0;
304 }
305
drv_ecg_adi_adpd188gg_set_afe_tia(i2c_dev_t * drv)306 static int drv_ecg_adi_adpd188gg_set_afe_tia(i2c_dev_t* drv)
307 {
308 int ret = 0;
309 uint8_t value[2];
310
311 value[0] = 0x22, value[1] = 0x1C;
312 ret = sensor_i2c_write(drv, ADPD188GG_SLOTA_AFE_WINDOW, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
313 if(unlikely(ret)){
314 return ret;
315 }
316
317 value[0] = 0x22, value[1] = 0x1C;
318 ret = sensor_i2c_write(drv, ADPD188GG_SLOTB_AFE_WINDOW, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
319 if(unlikely(ret)){
320 return ret;
321 }
322
323 value[0] = 0x31, value[1] = 0xC6;
324 ret = sensor_i2c_write(drv, ADPD188GG_AFE_POWER_CFG1, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
325 if(unlikely(ret)){
326 return ret;
327 }
328
329 value[0] = 0x1C, value[1] = 0x35;
330 ret = sensor_i2c_write(drv, ADPD188GG_SLOTA_TIA_CFG, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
331 if(unlikely(ret)){
332 return ret;
333 }
334
335 value[0] = 0xAD, value[1] = 0xA5;
336 ret = sensor_i2c_write(drv, ADPD188GG_SLOTA_AFE_CFG, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
337 if(unlikely(ret)){
338 return ret;
339 }
340
341 value[0] = 0x1C, value[1] = 0x34;
342 ret = sensor_i2c_write(drv, ADPD188GG_SLOTB_TIA_CFG, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
343 if(unlikely(ret)){
344 return ret;
345 }
346
347 value[0] = 0xAD, value[1] = 0xA5;
348 ret = sensor_i2c_write(drv, ADPD188GG_SLOTB_AFE_CFG, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
349 if(unlikely(ret)){
350 return ret;
351 }
352
353 value[0] = 0x70, value[1] = 0x40;
354 ret = sensor_i2c_write(drv, ADPD188GG_XXXX, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
355 if(unlikely(ret)){
356 return ret;
357 }
358
359 value[0] = 0x0A, value[1] = 0xA0;
360 ret = sensor_i2c_write(drv, ADPD188GG_AFE_POWER_CFG2, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
361 if(unlikely(ret)){
362 return ret;
363 }
364 return 0;
365 }
366
drv_ecg_adi_adpd188gg_set_flt(i2c_dev_t * drv)367 static int drv_ecg_adi_adpd188gg_set_flt(i2c_dev_t* drv)
368 {
369 int ret = 0;
370 uint8_t value[2];
371
372 value[0] = 0x03, value[1] = 0x20;
373 ret = sensor_i2c_write(drv, ADPD188GG_SLOTB_FLOAT_LED, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
374 if(unlikely(ret)){
375 return ret;
376 }
377
378 value[0] = 0x00, value[1] = 0x00;
379 ret = sensor_i2c_write(drv, ADPD188GG_MATH, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
380 if(unlikely(ret)){
381 return ret;
382 }
383
384 value[0] = 0x08, value[1] = 0x08;
385 ret = sensor_i2c_write(drv, ADPD188GG_FLT_CONGIG_B, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
386 if(unlikely(ret)){
387 return ret;
388 }
389
390 value[0] = 0x00, value[1] = 0x10;
391 ret = sensor_i2c_write(drv, ADPD188GG_FLT_LED_FIRE, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
392 if(unlikely(ret)){
393 return ret;
394 }
395
396 return 0;
397 }
398
drv_ecg_adi_adpd188gg_set_program(i2c_dev_t * drv)399 static int drv_ecg_adi_adpd188gg_set_program(i2c_dev_t* drv)
400 {
401 uint8_t ret;
402 uint8_t value[2];
403
404 value[0] = 0x00, value[1] = 0x01;
405 ret = sensor_i2c_write(drv, ADPD188GG_MODE, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
406 if(unlikely(ret)){
407 return ret;
408 }
409
410 value[0] = 0x80, value[1] = 0xFF;
411 ret = sensor_i2c_write(drv, ADPD188GG_STATUS, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
412 if(unlikely(ret)){
413 return ret;
414 }
415
416 value[0] = 0x00, value[1] = 0xFF;
417 ret = sensor_i2c_write(drv, ADPD188GG_INT_MASK, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
418 if(unlikely(ret)){
419 return ret;
420 }
421
422 value[0] = 0x26, value[1] = 0x9A;
423 ret = sensor_i2c_write(drv, ADPD188GG_SAMPLE_CLOCK, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
424 if(unlikely(ret)){
425 return ret;
426 }
427
428 value[0] = 0x00, value[1] = 0x90;
429 ret = sensor_i2c_write(drv, ADPD188GG_CLK32_ADJUST, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
430 if(unlikely(ret)){
431 return ret;
432 }
433
434 return 0;
435 }
436
drv_ecg_adi_adpd188gg_irq_handle(void)437 static void drv_ecg_adi_adpd188gg_irq_handle(void)
438 {
439 /* no handle so far */
440 }
441
drv_ecg_adi_adpd188gg_open(void)442 static int drv_ecg_adi_adpd188gg_open(void)
443 {
444 int ret = 0;
445 ret = drv_ecg_adi_adpd188gg_set_power_mode(&adpd188gg_ctx, DEV_POWER_ON);
446 if(unlikely(ret)){
447 return -1;
448 }
449 return 0;
450
451 }
452
drv_ecg_adi_adpd188gg_close(void)453 static int drv_ecg_adi_adpd188gg_close(void)
454 {
455 int ret = 0;
456 ret = drv_ecg_adi_adpd188gg_set_power_mode(&adpd188gg_ctx, DEV_POWER_OFF);
457 if(unlikely(ret)){
458 return -1;
459 }
460 return 0;
461 }
462
drv_ecg_adi_adpd188gg_read(void * buf,size_t len)463 static int drv_ecg_adi_adpd188gg_read(void *buf, size_t len)
464 {
465
466 int ret = 0;
467 uint8_t value[2];
468 size_t size;
469 ecg_data_t *ecg = (ecg_data_t *)buf;
470
471 if(buf == NULL){
472 return -1;
473 }
474 size = sizeof(ecg_data_t);
475 if(len < size){
476 return -1;
477 }
478
479 ret = sensor_i2c_read(&adpd188gg_ctx, ADPD188GG_STATUS, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
480 if(unlikely(ret)){
481 return -1;
482 }
483
484 ret = sensor_i2c_read(&adpd188gg_ctx, ADPD188GG_FIFO_ACCESS, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
485 if(unlikely(ret)){
486 return -1;
487 }
488
489 ecg->raw_data = (uint16_t)(value[0]<<8 | value[1]);
490 ecg->timestamp = aos_now_ms();
491
492 return (int)size;
493 }
494
drv_ecg_adi_adpd188gg_ioctl(int cmd,unsigned long arg)495 static int drv_ecg_adi_adpd188gg_ioctl(int cmd, unsigned long arg)
496 {
497 int ret = 0;
498 dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
499 switch(cmd){
500 case SENSOR_IOCTL_ODR_SET:{
501 ret = drv_ecg_adi_adpd188gg_set_odr(&adpd188gg_ctx, arg);
502 if(unlikely(ret)){
503 return -1;
504 }
505 }break;
506 case SENSOR_IOCTL_SET_POWER:{
507 ret = drv_ecg_adi_adpd188gg_set_power_mode(&adpd188gg_ctx, arg);
508 if(unlikely(ret)){
509 return -1;
510 }
511 }break;
512 case SENSOR_IOCTL_GET_INFO:{
513 /* fill the dev info here */
514 info->model = "ADPD188GG";
515 info->range_max = 150;
516 info->range_min = 1;
517 info->unit = bpm;
518 }break;
519
520 default:break;
521 }
522
523 return 0;
524 }
525
drv_ecg_adi_adpd188gg_init(void)526 int drv_ecg_adi_adpd188gg_init(void){
527 int ret = 0;
528 uint8_t value[2];
529 sensor_obj_t sensor;
530 memset(&sensor, 0, sizeof(sensor));
531
532 /* fill the sensor obj parameters here */
533 sensor.io_port = I2C_PORT;
534 sensor.tag = TAG_DEV_HR;
535 sensor.path = dev_hr_path;
536 sensor.open = drv_ecg_adi_adpd188gg_open;
537 sensor.close = drv_ecg_adi_adpd188gg_close;
538 sensor.read = drv_ecg_adi_adpd188gg_read;
539 sensor.write = NULL;
540 sensor.ioctl = drv_ecg_adi_adpd188gg_ioctl;
541 sensor.irq_handle = drv_ecg_adi_adpd188gg_irq_handle;
542
543 ret = sensor_create_obj(&sensor);
544 if(unlikely(ret)){
545 return -1;
546 }
547
548 ret = drv_ecg_adi_adpd188gg_validate_id(&adpd188gg_ctx, ADPD188GG_DEVICE_ID_VALUE);
549 if(unlikely(ret)){
550 return -1;
551 }
552 ret = drv_ecg_adi_adpd188gg_soft_reset(&adpd188gg_ctx);
553 if(unlikely(ret)){
554 return -1;
555 }
556 ret = drv_ecg_adi_adpd188gg_set_program(&adpd188gg_ctx);
557 if(unlikely(ret)){
558 return -1;
559 }
560 //set odr is 100hz, and will update
561 ret = drv_ecg_adi_adpd188gg_set_odr(&adpd188gg_ctx, ADPD188GG_DEFAULT_ODR_100HZ);
562 if(unlikely(ret)){
563 return -1;
564 }
565
566 ret = drv_ecg_adi_adpd188gg_set_offset(&adpd188gg_ctx);
567 if(unlikely(ret)){
568 return -1;
569 }
570
571 ret = drv_ecg_adi_adpd188gg_set_led_coarse(&adpd188gg_ctx);
572 if(unlikely(ret)){
573 return -1;
574 }
575
576 ret = drv_ecg_adi_adpd188gg_set_led(&adpd188gg_ctx);
577 if(unlikely(ret)){
578 return -1;
579 }
580
581 ret = drv_ecg_adi_adpd188gg_set_afe_tia(&adpd188gg_ctx);
582 if(unlikely(ret)){
583 return -1;
584 }
585
586 ret = drv_ecg_adi_adpd188gg_set_flt(&adpd188gg_ctx);
587 if(unlikely(ret)){
588 return -1;
589 }
590
591 ret = drv_ecg_adi_adpd188gg_set_power_mode(&adpd188gg_ctx, DEV_POWER_ON);
592 if(unlikely(ret)){
593 return -1;
594 }
595
596 ret = sensor_i2c_read(&adpd188gg_ctx, ADPD188GG_MODE, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
597 if(unlikely(ret)){
598 return ret;
599 }
600 /* update the phy sensor info to sensor hal */
601 LOG("%s %s successfully \n", SENSOR_STR, __func__);
602 return 0;
603 }
604
605 SENSOR_DRV_ADD(drv_ecg_adi_adpd188gg_init);