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
11 #include "aos/kernel.h"
12 #include "ulog/ulog.h"
13
14 #include "sensor_drv_api.h"
15 #include "sensor_hal.h"
16
17 #define LTR553_ALS_CONTR 0x80 /* ALS operation mode, SW reset */
18 #define LTR553_PS_CONTR 0x81 /* PS operation mode */
19 #define LTR553_PS_LED 0x82 /* LED pulse freq, current duty, peak current */
20 #define LTR553_PS_MEAS_RATE 0x84 /* measurement rate*/
21 #define LTR553_ALS_MEAS_RATE 0x85 /* ALS integ time, measurement rate*/
22 #define LTR553_PART_ID 0x86
23 #define LTR553_MANUFAC_ID 0x87
24 #define LTR553_ALS_DATA1_L 0x88
25 #define LTR553_ALS_DATA1_H 0x89
26 #define LTR553_ALS_DATA0_L 0x8a
27 #define LTR553_ALS_DATA0_H 0x8b
28 #define LTR553_ALS_PS_STATUS 0x8c
29 #define LTR553_PS_DATA_L 0x8d
30 #define LTR553_PS_DATA_H 0x8e
31 #define LTR553_INTR 0x8f /* output mode, polarity, mode */
32 #define LTR553_PS_THRESH_UP 0x90 /* 11 bit, ps upper threshold */
33 #define LTR553_PS_THRESH_LOW 0x92 /* 11 bit, ps lower threshold */
34 #define LTR553_ALS_THRESH_UP 0x97 /* 16 bit, ALS upper threshold */
35 #define LTR553_ALS_THRESH_LOW 0x99 /* 16 bit, ALS lower threshold */
36 #define LTR553_INTR_PRST 0x9e /* ps thresh, als thresh */
37 #define LTR553_MAX_REG 0x9f
38
39 #define LTR553_I2C_SLAVE_ADDR 0x23
40
41 #define LTR553_ADDR_TRANS(n) ((n) << 1)
42 #define LTR553_I2C_ADDR LTR553_ADDR_TRANS(LTR553_I2C_SLAVE_ADDR)
43 #define LTR553_PART_ID_VAL 0x92
44 #define LTR553_MANUFAC_ID_VAL 0x05
45
46 #define LTR553_ALS_CONTR_REG_ALS_GAIN__POS (2)
47 #define LTR553_ALS_CONTR_REG_ALS_GAIN__MSK (0x1c)
48 #define LTR553_ALS_CONTR_REG_ALS_GAIN__REG (LTR553_ALS_CONTR)
49
50 #define LTR553_ALS_CONTR_REG_ALS_MODE__POS (0)
51 #define LTR553_ALS_CONTR_REG_ALS_MODE__MSK (0x01)
52 #define LTR553_ALS_CONTR_REG_ALS_MODE__REG (LTR553_ALS_CONTR)
53
54 #define LTR553_ALS_MEAS_RATE_REG_INTEG_TIME__POS (3)
55 #define LTR553_ALS_MEAS_RATE_REG_INTEG_TIME__MSK (0x38)
56 #define LTR553_ALS_MEAS_RATE_REG_INTEG_TIME__REG (LTR553_ALS_MEAS_RATE)
57
58 #define LTR553_ALS_MEAS_RATE_REG_MEAS_RATE__POS (0)
59 #define LTR553_ALS_MEAS_RATE_REG_MEAS_RATE__MSK (0x07)
60 #define LTR553_ALS_MEAS_RATE_REG_MEAS_RATE__REG (LTR553_ALS_MEAS_RATE)
61
62 #define LTR553_ALS_PS_STATUS_REG_ALS_STATUS__POS (2)
63 #define LTR553_ALS_PS_STATUS_REG_ALS_STATUS__MSK (0x04)
64 #define LTR553_ALS_PS_STATUS_REG_ALS_STATUS__REG (LTR553_ALS_PS_STATUS)
65
66 #define LTR553_PS_CONTR_REG_PS_GAIN__POS (2)
67 #define LTR553_PS_CONTR_REG_PS_GAIN__MSK (0x0c)
68 #define LTR553_PS_CONTR_REG_PS_GAIN__REG (LTR553_PS_CONTR)
69
70 #define LTR553_PS_CONTR_REG_PS_MODE__POS (0)
71 #define LTR553_PS_CONTR_REG_PS_MODE__MSK (0x03)
72 #define LTR553_PS_CONTR_REG_PS_MODE__REG (LTR553_PS_CONTR)
73
74 #define LTR553_PS_LED_REG_PLUSE_FREQ__POS (5)
75 #define LTR553_PS_LED_REG_PLUSE_FREQ__MSK (0xe0)
76 #define LTR553_PS_LED_REG_PLUSE_FREQ__REG (LTR553_PS_LED)
77
78 #define LTR553_PS_LED_REG_CURRENT_DUTY__POS (3)
79 #define LTR553_PS_LED_REG_CURRENT_DUTY__MSK (0x18)
80 #define LTR553_PS_LED_REG_CURRENT_DUTY__REG (LTR553_PS_LED)
81
82 #define LTR553_PS_LED_REG_CURRENT__POS (0)
83 #define LTR553_PS_LED_REG_CURRENT__MSK (0x07)
84 #define LTR553_PS_LED_REG_CURRENT__REG (LTR553_PS_LED)
85
86 #define LTR553_PS_MEAS_RATE_REG_MEAS_RATE__POS (0)
87 #define LTR553_PS_MEAS_RATE_REG_MEAS_RATE__MSK (0x0F)
88 #define LTR553_PS_MEAS_RATE_REG_MEAS_RATE__REG (LTR553_PS_MEAS_RATE)
89
90 #define LTR553_ALS_PS_STATUS_REG_PS_STATUS__POS (0)
91 #define LTR553_ALS_PS_STATUS_REG_PS_STATUS__MSK (0x01)
92 #define LTR553_ALS_PS_STATUS_REG_PS_STATUS__REG (LTR553_ALS_PS_STATUS)
93
94 #define LTR553_GET_BITSLICE(regvar, bitname) \
95 ((regvar & bitname##__MSK) >> bitname##__POS)
96 #define LTR553_SET_BITSLICE(regvar, bitname, val) \
97 ((regvar & ~bitname##__MSK) | ((val << bitname##__POS) & bitname##__MSK))
98
99 #define LTR553_WAIT_TIME_PER_CHECK (10)
100 #define LTR553_WAIT_TIME_TOTAL (1000)
101
102 typedef enum
103 {
104 AG_GAIN_1X = 0x0, /* 1 lux to 64k lux (default) */
105 AG_GAIN_2X = 0x1, /* 0.5 lux to 32k lux */
106 AG_GAIN_4X = 0x2, /* 0.25 lux to 16k lux */
107 AG_GAIN_8X = 0x3, /* 0.125 lux to 8k lux */
108 AG_GAIN_48X = 0x6, /* 0.02 lux to 1.3k lux */
109 AG_GAIN_96X = 0x7, /* 0.01 lux to 600 lux */
110 } CFG_ALS_Gain;
111
112 typedef enum
113 {
114 PG_GAIN_X16 = 0x0, /* X16 (default) */
115 PG_GAIN_X32 = 0x2, /* X32 */
116 PG_GAIN_X64 = 0x3, /* X64 */
117 } CFG_PS_Gain;
118
119 typedef enum
120 {
121 LPMF_PERIOD_30K = 0x0, /* LED pulse period = 30kHz */
122 LPMF_PERIOD_40K = 0x1, /* LED pulse period = 40kHz */
123 LPMF_PERIOD_50K = 0x2, /* LED pulse period = 50kHz */
124 LPMF_PERIOD_60K = 0x3, /* LED pulse period = 60kHz(default) */
125 LPMF_PERIOD_70K = 0x4, /* LED pulse period = 70kHz */
126 LPMF_PERIOD_80K = 0x5, /* LED pulse period = 80kHz */
127 LPMF_PERIOD_90K = 0x6, /* LED pulse period = 90kHz */
128 LPMF_PERIOD_100K = 0x7, /* LED pulse period = 100kHz */
129 } CFG_LED_pulse_Modulation_Frequency;
130
131 typedef enum
132 {
133 LCD_PER_25 = 0x0, /* DUTY = 25% */
134 LCD_PER_50 = 0x1, /* DUTY = 50% */
135 LCD_PER_75 = 0x2, /* DUTY = 75% */
136 LCD_PER_100 = 0x3, /* DUTY = 100%(default) */
137 } CFG_LED_Current_DUTY;
138
139 typedef enum
140 {
141 LC_LEVEL_5 = 0x0, /* LED pulse current level = 5mA */
142 LC_LEVEL_10 = 0x1, /* LED pulse current level = 10mA */
143 LC_LEVEL_20 = 0x2, /* LED pulse current level = 20mA */
144 LC_LEVEL_50 = 0x3, /* LED pulse current level = 50mA */
145 LC_LEVEL_100 = 0x4, /* LED pulse current level = 100mA(default) */
146 } CFG_LED_Current;
147
148 typedef enum
149 {
150 PMR_RATE_50 = 0x0, /* PS Measurement Repeat Rate = 50ms */
151 PMR_RATE_70 = 0x1, /* PS Measurement Repeat Rate = 70ms */
152 PMR_RATE_100 = 0x2, /* PS Measurement Repeat Rate = 100ms(default) */
153 PMR_RATE_200 = 0x3, /* PS Measurement Repeat Rate = 200ms */
154 PMR_RATE_500 = 0x4, /* PS Measurement Repeat Rate = 500ms */
155 PMR_RATE_1000 = 0x5, /* PS Measurement Repeat Rate = 1000ms */
156 PMR_RATE_2000 = 0x6, /* PS Measurement Repeat Rate = 2000ms */
157 PMR_RATE_10 = 0x8, /* PS Measurement Repeat Rate = 10ms */
158 } CFG_PS_measurement_rate;
159
160 typedef enum
161 {
162 AIT_TIME_100 = 0x0, /* ALS integration_time = 100ms(default) */
163 AIT_TIME_50 = 0x1, /* ALS integration_time = 50ms */
164 AIT_TIME_200 = 0x2, /* ALS integration_time = 200ms */
165 AIT_TIME_400 = 0x3, /* ALS integration_time = 400ms */
166 AIT_TIME_150 = 0x4, /* ALS integration_time = 150ms */
167 AIT_TIME_250 = 0x5, /* ALS integration_time = 250ms */
168 AIT_TIME_300 = 0x6, /* ALS integration_time = 300ms */
169 AIT_TIME_350 = 0x7, /* ALS integration_time = 350ms */
170 } CFG_ALS_integration_time;
171
172 typedef enum
173 {
174 AMR_RATE_50 = 0x0, /* ALS Measurement Repeat Rate = 50ms */
175 AMR_RATE_100 = 0x1, /* ALS Measurement Repeat Rate = 100ms */
176 AMR_RATE_200 = 0x2, /* ALS Measurement Repeat Rate = 200ms */
177 AMR_RATE_500 = 0x3, /* ALS Measurement Repeat Rate = 500ms(default) */
178 AMR_RATE_1000 = 0x4, /* ALS Measurement Repeat Rate = 1000ms */
179 AMR_RATE_2000 = 0x5, /* ALS Measurement Repeat Rate = 2000ms */
180 } CFG_ALS_measurement_rate;
181
182 typedef enum
183 {
184 PM_MODE_STANDBY = 0,
185 PM_MODE_ACTIVE = 3,
186 } CFG_PS_mode;
187
188 typedef enum
189 {
190 AM_MODE_STANDBY = 0,
191 AM_MODE_ACTIVE = 1,
192 } CFG_ALS_mode;
193
194 typedef enum
195 {
196 ADS_STATUS_OLD = 0,
197 ADS_STATUS_NEW = 1,
198 } CFG_ALS_data_status;
199
200 typedef enum
201 {
202 PDS_STATUS_OLD = 0,
203 PDS_STATUS_NEW = 1,
204 } CFG_PS_data_status;
205
206 typedef enum
207 {
208 FLAG_INIT_ALS = 0,
209 FLAG_INIT_PS,
210 } FLAG_INIT_BIT;
211
212 i2c_dev_t ltr553_ctx = {
213 .port = 2,
214 .config.address_width = 8,
215 .config.freq = 100000,
216 .config.dev_addr = LTR553_I2C_ADDR,
217 };
218
219 static uint8_t g_init_bitwise = 0;
220
drv_als_ps_liteon_ltr553_validate_id(i2c_dev_t * drv,uint8_t part_id,uint8_t manufac_id)221 static int drv_als_ps_liteon_ltr553_validate_id(i2c_dev_t *drv, uint8_t part_id,
222 uint8_t manufac_id)
223 {
224 int ret = 0;
225 uint8_t part_id_value = 0;
226 uint8_t manufac_id_value = 0;
227
228 if (drv == NULL) {
229 return -1;
230 }
231
232 ret = sensor_i2c_read(drv, LTR553_PART_ID, &part_id_value, I2C_DATA_LEN,
233 I2C_OP_RETRIES);
234 if (unlikely(ret)) {
235 return ret;
236 }
237
238 ret = sensor_i2c_read(drv, LTR553_MANUFAC_ID, &manufac_id_value,
239 I2C_DATA_LEN, I2C_OP_RETRIES);
240 if (unlikely(ret)) {
241 return ret;
242 }
243
244 if (part_id_value != part_id || manufac_id_value != manufac_id) {
245 return -1;
246 }
247
248 return 0;
249 }
250
drv_als_liteon_ltr553_set_power_mode(i2c_dev_t * drv,dev_power_mode_e mode)251 static int drv_als_liteon_ltr553_set_power_mode(i2c_dev_t * drv,
252 dev_power_mode_e mode)
253 {
254 int ret = 0;
255 uint8_t dev_mode = 0;
256 uint8_t value = 0;
257
258 ret = sensor_i2c_read(drv, LTR553_ALS_CONTR, &value, I2C_DATA_LEN,
259 I2C_OP_RETRIES);
260 if (unlikely(ret)) {
261 return ret;
262 }
263
264 switch (mode) {
265 case DEV_POWER_OFF:
266 case DEV_SLEEP:
267 dev_mode = LTR553_SET_BITSLICE(
268 dev_mode, LTR553_ALS_CONTR_REG_ALS_MODE, AM_MODE_STANDBY);
269 break;
270 case DEV_POWER_ON:
271 dev_mode = LTR553_SET_BITSLICE(
272 dev_mode, LTR553_ALS_CONTR_REG_ALS_MODE, AM_MODE_ACTIVE);
273 break;
274 default:
275 return -1;
276 }
277
278 ret = sensor_i2c_write(drv, LTR553_ALS_CONTR, &dev_mode, I2C_DATA_LEN,
279 I2C_OP_RETRIES);
280 if (unlikely(ret)) {
281 return ret;
282 }
283
284 return 0;
285 }
286
drv_ps_liteon_ltr553_set_power_mode(i2c_dev_t * drv,dev_power_mode_e mode)287 static int drv_ps_liteon_ltr553_set_power_mode(i2c_dev_t * drv,
288 dev_power_mode_e mode)
289 {
290 int ret = 0;
291 uint8_t dev_mode = 0;
292 uint8_t value = 0;
293
294 ret = sensor_i2c_read(drv, LTR553_PS_CONTR, &value, I2C_DATA_LEN,
295 I2C_OP_RETRIES);
296 if (unlikely(ret)) {
297 return ret;
298 }
299
300 switch (mode) {
301 case DEV_POWER_OFF:
302 case DEV_SLEEP:
303 dev_mode = LTR553_SET_BITSLICE(value, LTR553_PS_CONTR_REG_PS_MODE,
304 PM_MODE_STANDBY);
305 break;
306 case DEV_POWER_ON:
307 dev_mode = LTR553_SET_BITSLICE(value, LTR553_PS_CONTR_REG_PS_MODE,
308 PM_MODE_ACTIVE);
309 break;
310 default:
311 return -1;
312 }
313
314 ret = sensor_i2c_write(drv, LTR553_PS_CONTR, &dev_mode, I2C_DATA_LEN,
315 I2C_OP_RETRIES);
316 if (unlikely(ret)) {
317 return ret;
318 }
319
320 return 0;
321 }
322
drv_als_liteon_ltr553_is_ready(i2c_dev_t * drv)323 UNUSED static int drv_als_liteon_ltr553_is_ready(i2c_dev_t *drv)
324 {
325 int ret = 0;
326 uint8_t value = 0;
327
328 ret = sensor_i2c_read(drv, LTR553_ALS_PS_STATUS, &value, I2C_DATA_LEN,
329 I2C_OP_RETRIES);
330 if (unlikely(ret)) {
331 return 0;
332 }
333
334 ret = (LTR553_GET_BITSLICE(value, LTR553_ALS_PS_STATUS_REG_ALS_STATUS) ==
335 ADS_STATUS_NEW)
336 ? 1
337 : 0;
338
339 return ret;
340 }
341
drv_ps_liteon_ltr553_is_ready(i2c_dev_t * drv)342 UNUSED static int drv_ps_liteon_ltr553_is_ready(i2c_dev_t *drv)
343 {
344 int ret = 0;
345 uint8_t value = 0;
346
347 ret = sensor_i2c_read(drv, LTR553_ALS_PS_STATUS, &value, I2C_DATA_LEN,
348 I2C_OP_RETRIES);
349 if (unlikely(ret)) {
350 return 0;
351 }
352
353 ret = (LTR553_GET_BITSLICE(value, LTR553_ALS_PS_STATUS_REG_PS_STATUS) ==
354 PDS_STATUS_NEW)
355 ? 1
356 : 0;
357
358 return ret;
359 }
360
drv_als_liteon_ltr553_set_default_config(i2c_dev_t * drv)361 static int drv_als_liteon_ltr553_set_default_config(i2c_dev_t *drv)
362 {
363 int ret = 0;
364 uint8_t value = 0;
365
366 value = LTR553_SET_BITSLICE(value, LTR553_ALS_MEAS_RATE_REG_INTEG_TIME,
367 AIT_TIME_100);
368 value = LTR553_SET_BITSLICE(value, LTR553_ALS_MEAS_RATE_REG_MEAS_RATE,
369 AMR_RATE_100);
370 ret = sensor_i2c_write(drv, LTR553_ALS_MEAS_RATE, &value, I2C_DATA_LEN,
371 I2C_OP_RETRIES);
372 if (unlikely(ret)) {
373 return ret;
374 }
375
376 ret = sensor_i2c_read(drv, LTR553_ALS_CONTR, &value, I2C_DATA_LEN,
377 I2C_OP_RETRIES);
378 if (unlikely(ret)) {
379 return ret;
380 }
381 value =
382 LTR553_SET_BITSLICE(value, LTR553_ALS_CONTR_REG_ALS_GAIN, AG_GAIN_1X);
383 ret = sensor_i2c_write(drv, LTR553_ALS_CONTR, &value, I2C_DATA_LEN,
384 I2C_OP_RETRIES);
385 if (unlikely(ret)) {
386 return ret;
387 }
388
389 return 0;
390 }
391
drv_ps_liteon_ltr553_set_default_config(i2c_dev_t * drv)392 static int drv_ps_liteon_ltr553_set_default_config(i2c_dev_t *drv)
393 {
394 int ret = 0;
395 uint8_t value = 0;
396
397 value = LTR553_SET_BITSLICE(value, LTR553_PS_MEAS_RATE_REG_MEAS_RATE,
398 PMR_RATE_100);
399 ret = sensor_i2c_write(drv, LTR553_PS_MEAS_RATE, &value, I2C_DATA_LEN,
400 I2C_OP_RETRIES);
401 if (unlikely(ret)) {
402 return ret;
403 }
404
405 value = 0;
406 value =
407 LTR553_SET_BITSLICE(value, LTR553_PS_LED_REG_PLUSE_FREQ, LPMF_PERIOD_60K);
408 value =
409 LTR553_SET_BITSLICE(value, LTR553_PS_LED_REG_CURRENT_DUTY, LCD_PER_100);
410 value = LTR553_SET_BITSLICE(value, LTR553_PS_LED_REG_CURRENT, LC_LEVEL_100);
411 ret = sensor_i2c_write(drv, LTR553_PS_MEAS_RATE, &value, I2C_DATA_LEN,
412 I2C_OP_RETRIES);
413 if (unlikely(ret)) {
414 return ret;
415 }
416
417 ret = sensor_i2c_read(drv, LTR553_PS_CONTR, &value, I2C_DATA_LEN,
418 I2C_OP_RETRIES);
419 if (unlikely(ret)) {
420 return ret;
421 }
422 value =
423 LTR553_SET_BITSLICE(value, LTR553_PS_CONTR_REG_PS_GAIN, PG_GAIN_X16);
424 ret = sensor_i2c_write(drv, LTR553_PS_CONTR, &value, I2C_DATA_LEN,
425 I2C_OP_RETRIES);
426 if (unlikely(ret)) {
427 return ret;
428 }
429
430 return 0;
431 }
432
drv_als_liteon_ltr553_irq_handle(void)433 static void drv_als_liteon_ltr553_irq_handle(void)
434 {
435 /* no handle so far */
436 }
437
drv_als_liteon_ltr553_open(void)438 static int drv_als_liteon_ltr553_open(void)
439 {
440 int ret = 0;
441
442 ret = drv_als_liteon_ltr553_set_power_mode(<r553_ctx, DEV_POWER_ON);
443 if (unlikely(ret)) {
444 return -1;
445 }
446
447 LOG("%s %s successfully \n", SENSOR_STR, __func__);
448 return 0;
449 }
450
drv_als_liteon_ltr553_close(void)451 static int drv_als_liteon_ltr553_close(void)
452 {
453 int ret = 0;
454
455 ret = drv_als_liteon_ltr553_set_power_mode(<r553_ctx, DEV_POWER_OFF);
456 if (unlikely(ret)) {
457 return -1;
458 }
459
460 LOG("%s %s successfully \n", SENSOR_STR, __func__);
461 return 0;
462 }
463
drv_als_liteon_ltr553_read(void * buf,size_t len)464 static int drv_als_liteon_ltr553_read(void *buf, size_t len)
465 {
466 int ret = 0;
467 size_t size;
468 uint16_t als_raw[2] = { 0 };
469 uint8_t reg_ch0[2] = { 0 };
470 uint8_t reg_ch1[2] = { 0 };
471 als_data_t *pdata = (als_data_t *)buf;
472
473 if (buf == NULL) {
474 return -1;
475 }
476
477 size = sizeof(als_data_t);
478 if (len < size) {
479 return -1;
480 }
481
482
483 ret = sensor_i2c_read(<r553_ctx, LTR553_ALS_DATA1_L, ®_ch1[0],
484 I2C_DATA_LEN, I2C_OP_RETRIES);
485 if (unlikely(ret)) {
486 return -1;
487 }
488 ret = sensor_i2c_read(<r553_ctx, LTR553_ALS_DATA1_H, ®_ch1[1],
489 I2C_DATA_LEN, I2C_OP_RETRIES);
490 if (unlikely(ret)) {
491 return -1;
492 }
493 ret = sensor_i2c_read(<r553_ctx, LTR553_ALS_DATA0_L, ®_ch0[0],
494 I2C_DATA_LEN, I2C_OP_RETRIES);
495 if (unlikely(ret)) {
496 return -1;
497 }
498 ret = sensor_i2c_read(<r553_ctx, LTR553_ALS_DATA0_H, ®_ch0[1],
499 I2C_DATA_LEN, I2C_OP_RETRIES);
500 if (unlikely(ret)) {
501 return -1;
502 }
503
504 als_raw[0] = (uint16_t)reg_ch0[1] << 8 | reg_ch0[0];
505 als_raw[1] = (uint16_t)reg_ch1[1] << 8 | reg_ch1[0];
506 pdata->lux = (uint32_t)((als_raw[0] + als_raw[1]) >> 1);
507
508 pdata->timestamp = aos_now_ms();
509
510 return (int)size;
511 }
512
drv_als_liteon_ltr553_write(const void * buf,size_t len)513 static int drv_als_liteon_ltr553_write(const void *buf, size_t len)
514 {
515 (void)buf;
516 (void)len;
517 return 0;
518 }
519
drv_als_liteon_ltr553_ioctl(int cmd,unsigned long arg)520 static int drv_als_liteon_ltr553_ioctl(int cmd, unsigned long arg)
521 {
522 int ret = 0;
523
524 switch (cmd) {
525 case SENSOR_IOCTL_SET_POWER: {
526 ret = drv_als_liteon_ltr553_set_power_mode(<r553_ctx, arg);
527 if (unlikely(ret)) {
528 return -1;
529 }
530 } break;
531 case SENSOR_IOCTL_GET_INFO: {
532 /* fill the dev info here */
533 dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
534 info->model = "LTR553";
535 info->unit = lux;
536 } break;
537 default:
538 return -1;
539 }
540
541 LOG("%s %s successfully \n", SENSOR_STR, __func__);
542 return 0;
543 }
544
drv_ps_liteon_ltr553_irq_handle(void)545 static void drv_ps_liteon_ltr553_irq_handle(void)
546 {
547 /* no handle so far */
548 }
549
drv_ps_liteon_ltr553_open(void)550 static int drv_ps_liteon_ltr553_open(void)
551 {
552 int ret = 0;
553
554 ret = drv_ps_liteon_ltr553_set_power_mode(<r553_ctx, DEV_POWER_ON);
555 if (unlikely(ret)) {
556 return -1;
557 }
558
559 LOG("%s %s successfully \n", SENSOR_STR, __func__);
560 return 0;
561 }
562
drv_ps_liteon_ltr553_close(void)563 static int drv_ps_liteon_ltr553_close(void)
564 {
565 int ret = 0;
566
567 ret = drv_ps_liteon_ltr553_set_power_mode(<r553_ctx, DEV_POWER_OFF);
568 if (unlikely(ret)) {
569 return -1;
570 }
571
572 LOG("%s %s successfully \n", SENSOR_STR, __func__);
573 return 0;
574 }
575
drv_ps_liteon_ltr553_read(void * buf,size_t len)576 static int drv_ps_liteon_ltr553_read(void *buf, size_t len)
577 {
578 int ret = 0;
579 size_t size;
580 uint8_t reg_data[2] = { 0 };
581 proximity_data_t *pdata = (proximity_data_t *)buf;
582
583 if (buf == NULL) {
584 return -1;
585 }
586
587 size = sizeof(proximity_data_t);
588 if (len < size) {
589 return -1;
590 }
591
592 ret = sensor_i2c_read(<r553_ctx, LTR553_PS_DATA_L, ®_data[0],
593 I2C_DATA_LEN, I2C_OP_RETRIES);
594 if (unlikely(ret)) {
595 return -1;
596 }
597 ret = sensor_i2c_read(<r553_ctx, LTR553_PS_DATA_H, ®_data[1],
598 I2C_DATA_LEN, I2C_OP_RETRIES);
599 if (unlikely(ret)) {
600 return -1;
601 }
602
603 pdata->present = (uint32_t)(reg_data[1] << 8 | reg_data[0]);
604
605 pdata->timestamp = aos_now_ms();
606
607 return (int)size;
608 }
609
drv_ps_liteon_ltr553_write(const void * buf,size_t len)610 static int drv_ps_liteon_ltr553_write(const void *buf, size_t len)
611 {
612 (void)buf;
613 (void)len;
614 return 0;
615 }
616
drv_ps_liteon_ltr553_ioctl(int cmd,unsigned long arg)617 static int drv_ps_liteon_ltr553_ioctl(int cmd, unsigned long arg)
618 {
619 int ret = 0;
620
621 switch (cmd) {
622 case SENSOR_IOCTL_SET_POWER: {
623 ret = drv_ps_liteon_ltr553_set_power_mode(<r553_ctx, arg);
624 if (unlikely(ret)) {
625 return -1;
626 }
627 } break;
628 case SENSOR_IOCTL_GET_INFO: {
629 /* fill the dev info here */
630 dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
631 info->model = "LTR553";
632 info->unit = cm;
633 } break;
634 default:
635 return -1;
636 }
637
638 LOG("%s %s successfully \n", SENSOR_STR, __func__);
639 return 0;
640 }
641
drv_als_liteon_ltr553_init(void)642 int drv_als_liteon_ltr553_init(void)
643 {
644 int ret = 0;
645 sensor_obj_t sensor_als;
646
647 memset(&sensor_als, 0, sizeof(sensor_als));
648
649 if (!g_init_bitwise) {
650 ret = drv_als_ps_liteon_ltr553_validate_id(
651 <r553_ctx, LTR553_PART_ID_VAL, LTR553_MANUFAC_ID_VAL);
652 if (unlikely(ret)) {
653 return -1;
654 }
655 }
656
657 if (!(g_init_bitwise & (1 << FLAG_INIT_ALS))) {
658 /* fill the sensor_als obj parameters here */
659 sensor_als.tag = TAG_DEV_ALS;
660 sensor_als.path = dev_als_path;
661 sensor_als.io_port = I2C_PORT;
662 sensor_als.open = drv_als_liteon_ltr553_open;
663 sensor_als.close = drv_als_liteon_ltr553_close;
664 sensor_als.read = drv_als_liteon_ltr553_read;
665 sensor_als.write = drv_als_liteon_ltr553_write;
666 sensor_als.ioctl = drv_als_liteon_ltr553_ioctl;
667 sensor_als.irq_handle = drv_als_liteon_ltr553_irq_handle;
668
669 ret = sensor_create_obj(&sensor_als);
670 if (unlikely(ret)) {
671 return -1;
672 }
673
674 ret = drv_als_liteon_ltr553_set_default_config(<r553_ctx);
675 if (unlikely(ret)) {
676 return -1;
677 }
678
679 g_init_bitwise |= 1 << FLAG_INIT_ALS;
680 }
681
682 LOG("%s %s successfully \n", SENSOR_STR, __func__);
683 return 0;
684 }
685
drv_ps_liteon_ltr553_init(void)686 int drv_ps_liteon_ltr553_init(void)
687 {
688 int ret = 0;
689 sensor_obj_t sensor_ps;
690
691 memset(&sensor_ps, 0, sizeof(sensor_ps));
692
693 if (!g_init_bitwise) {
694 ret = drv_als_ps_liteon_ltr553_validate_id(
695 <r553_ctx, LTR553_PART_ID_VAL, LTR553_MANUFAC_ID_VAL);
696 if (unlikely(ret)) {
697 return -1;
698 }
699 }
700
701 if (!(g_init_bitwise & (1 << FLAG_INIT_PS))) {
702 /* fill the sensor_ps obj parameters here */
703 sensor_ps.tag = TAG_DEV_PS;
704 sensor_ps.path = dev_ps_path;
705 sensor_ps.io_port = I2C_PORT;
706 sensor_ps.open = drv_ps_liteon_ltr553_open;
707 sensor_ps.close = drv_ps_liteon_ltr553_close;
708 sensor_ps.read = drv_ps_liteon_ltr553_read;
709 sensor_ps.write = drv_ps_liteon_ltr553_write;
710 sensor_ps.ioctl = drv_ps_liteon_ltr553_ioctl;
711 sensor_ps.irq_handle = drv_ps_liteon_ltr553_irq_handle;
712
713 ret = sensor_create_obj(&sensor_ps);
714 if (unlikely(ret)) {
715 return -1;
716 }
717
718 ret = drv_ps_liteon_ltr553_set_default_config(<r553_ctx);
719 if (unlikely(ret)) {
720 return -1;
721 }
722
723 g_init_bitwise |= 1 << FLAG_INIT_PS;
724 }
725
726 LOG("%s %s successfully \n", SENSOR_STR, __func__);
727 return 0;
728 }
729
730 SENSOR_DRV_ADD(drv_als_liteon_ltr553_init);
731 SENSOR_DRV_ADD(drv_ps_liteon_ltr553_init);
732
733
734