1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <string.h>
4 #include "aos/kernel.h"
5 #include "sensor_drv_api.h"
6 #include "sensor_hal.h"
7
8 #define LTR568_I2C_SLAVE_ADDR 0x23
9
10 #define LTR568_ALS_AVE_LIMIT 0x7E /* ALS digital averaging limit */
11 #define LTR568_ALS_AVE_FAC 0x7F /* ALS digital averaging factor */
12 #define LTR568_ALS_CONTR 0x80 /* ALS operation mode */
13 #define LTR568_PS_CONTR 0x81 /* PS operation mode, SW reset */
14 #define LTR568_PS_LED 0x82 /* PS LED pulse freq, current duty, peak current */
15 #define LTR568_PS_N_PULSES 0x83 /* PS number of pulses */
16 #define LTR568_PS_MEAS_RATE 0x84 /* PS measurement rate*/
17 #define LTR568_ALS_INT_TIME 0x85 /* ALS integ time, measurement rate*/
18 #define LTR568_PART_ID 0x86
19 #define LTR568_MANUFAC_ID 0x87
20 #define LTR568_ALS_STATUS 0x88
21 #define LTR568_IR_DATA_LSB 0x89 /* ALS/RGB measurement IR data, LSB */
22 #define LTR568_IR_DATA_MSB 0x8A /* ALS/RGB measurement IR data, MSB */
23 #define LTR568_GREEN_DATA_LSB 0x8B /* ALS/RGB measurement Green data, LSB */
24 #define LTR568_GREEN_DATA_MSB 0x8C /* ALS/RGB measurement Green data, MSB */
25 #define LTR568_PS_STATUS 0x91
26 #define LTR568_PS_DATA_LSB 0x92
27 #define LTR568_PS_DATA_MSB 0x93
28 #define LTR568_PS_SAR 0x94
29 #define LTR568_ALS_SAR 0x95
30 #define LTR568_INTERRUPT 0x98
31 #define LTR568_INTR_PRST 0x99 /* ALS/PS interrupt persist setting */
32 #define LTR568_PS_THRES_HIGH_LSB 0x9A /* PS interrupt upper threshold, lower byte */
33 #define LTR568_PS_THRES_HIGH_MSB 0x9B /* PS interrupt upper threshold, upper byte */
34 #define LTR568_PS_THRES_LOW_LSB 0x9C /* PS interrupt lower threshold, lower byte */
35 #define LTR568_PS_THRES_LOW_MSB 0x9D /* PS interrupt lower threshold, upper byte */
36 #define LTR568_PXTALK_LSB 0x9E /* Crosstalk correction on PS CH0 PD, lower byte */
37 #define LTR568_PXTALK_MSB 0x9F /* Crosstalk correction on PS CH0 PD, upper byte */
38 #define LTR568_PS_VREHL 0xB6 /* External PS VREHL value, affect PS */
39
40 #define LTR568_ADDR_TRANS(n) ((n) << 1)
41 #define LTR568_I2C_ADDR LTR568_ADDR_TRANS(LTR568_I2C_SLAVE_ADDR)
42 #define LTR568_PART_ID_VAL 0x1C
43 #define LTR568_MANUFAC_ID_VAL 0x05
44
45 #define LTR568_ALS_AVE_LIMIT_REG_ALS_AVE_LIMIT__POS (0)
46 #define LTR568_ALS_AVE_LIMIT_REG_ALS_AVE_LIMIT__MSK (0x03)
47 #define LTR568_ALS_AVE_LIMIT_REG_ALS_AVE_LIMIT__REG (LTR568_ALS_AVE_LIMIT)
48
49 #define LTR568_ALS_CONTR_REG_ALS_MODE__POS (0)
50 #define LTR568_ALS_CONTR_REG_ALS_MODE__MSK (0x01)
51 #define LTR568_ALS_CONTR_REG_ALS_MODE__REG (LTR568_ALS_CONTR)
52
53 #define LTR568_ALS_CONTR_REG_ALS_SAR__POS (1)
54 #define LTR568_ALS_CONTR_REG_ALS_SAR__MSK (0x02)
55 #define LTR568_ALS_CONTR_REG_ALS_SAR__REG (LTR568_ALS_CONTR)
56
57 #define LTR568_ALS_CONTR_REG_ALS_GAIN__POS (2)
58 #define LTR568_ALS_CONTR_REG_ALS_GAIN__MSK (0x1C)
59 #define LTR568_ALS_CONTR_REG_ALS_GAIN__REG (LTR568_ALS_CONTR)
60
61 #define LTR568_ALS_CONTR_REG_IR_EN__POS (5)
62 #define LTR568_ALS_CONTR_REG_IR_EN__MSK (0x20)
63 #define LTR568_ALS_CONTR_REG_IR_EN__REG (LTR568_ALS_CONTR)
64
65 #define LTR568_ALS_CONTR_REG_ALS_RES__POS (6)
66 #define LTR568_ALS_CONTR_REG_ALS_RES__MSK (0xC0)
67 #define LTR568_ALS_CONTR_REG_ALS_RES__REG (LTR568_ALS_CONTR)
68
69 #define LTR568_PS_CONTR_REG_SW_RESET__POS (0)
70 #define LTR568_PS_CONTR_REG_SW_RESET__MSK (0x01)
71 #define LTR568_PS_CONTR_REG_SW_RESET__REG (LTR568_PS_CONTR)
72
73 #define LTR568_PS_CONTR_REG_PS_MODE__POS (1)
74 #define LTR568_PS_CONTR_REG_PS_MODE__MSK (0x02)
75 #define LTR568_PS_CONTR_REG_PS_MODE__REG (LTR568_PS_CONTR)
76
77 #define LTR568_PS_CONTR_REG_FTN_NTF_EN__POS (2)
78 #define LTR568_PS_CONTR_REG_FTN_NTF_EN__MSK (0x04)
79 #define LTR568_PS_CONTR_REG_FTN_NTF_EN__REG (LTR568_PS_CONTR)
80
81 #define LTR568_PS_CONTR_REG_PS_OS__POS (3)
82 #define LTR568_PS_CONTR_REG_PS_OS__MSK (0x08)
83 #define LTR568_PS_CONTR_REG_PS_OS__REG (LTR568_PS_CONTR)
84
85 #define LTR568_PS_LED_REG_LED_CURR__POS (0)
86 #define LTR568_PS_LED_REG_LED_CURR__MSK (0x07)
87 #define LTR568_PS_LED_REG_LED_CURR__REG (LTR568_PS_LED)
88
89 #define LTR568_PS_LED_REG_PULSE_WIDTH__POS (3)
90 #define LTR568_PS_LED_REG_PULSE_WIDTH__MSK (0x18)
91 #define LTR568_PS_LED_REG_PULSE_WIDTH__REG (LTR568_PS_LED)
92
93 #define LTR568_PS_LED_REG_PULSE_DUTY__POS (5)
94 #define LTR568_PS_LED_REG_PULSE_DUTY__MSK (0x60)
95 #define LTR568_PS_LED_REG_PULSE_DUTY__REG (LTR568_PS_LED)
96
97 #define LTR568_PS_N_PULSES_REG_PULSE_COUNT__POS (0)
98 #define LTR568_PS_N_PULSES_REG_PULSE_COUNT__MSK (0x3F)
99 #define LTR568_PS_N_PULSES_REG_PULSE_COUNT__REG (LTR568_PS_N_PULSES)
100
101 #define LTR568_PS_N_PULSES_REG_PS_AVE_FAC__POS (6)
102 #define LTR568_PS_N_PULSES_REG_PS_AVE_FAC__MSK (0xC0)
103 #define LTR568_PS_N_PULSES_REG_PS_AVE_FAC__REG (LTR568_PS_N_PULSES)
104
105 #define LTR568_PS_MEAS_RATE_REG_MEAS_RATE__POS (0)
106 #define LTR568_PS_MEAS_RATE_REG_MEAS_RATE__MSK (0x07)
107 #define LTR568_PS_MEAS_RATE_REG_MEAS_RATE__REG (LTR568_PS_MEAS_RATE)
108
109 #define LTR568_ALS_INT_TIME_REG_MEAS_RATE__POS (0)
110 #define LTR568_ALS_INT_TIME_REG_MEAS_RATE__MSK (0x03)
111 #define LTR568_ALS_INT_TIME_REG_MEAS_RATE__REG (LTR568_ALS_INT_TIME)
112
113 #define LTR568_ALS_INT_TIME_REG_INTEG_TIME__POS (2)
114 #define LTR568_ALS_INT_TIME_REG_INTEG_TIME__MSK (0x0C)
115 #define LTR568_ALS_INT_TIME_REG_INTEG_TIME__REG (LTR568_ALS_INT_TIME)
116
117 #define LTR568_ALS_STATUS_REG_ALS_DATA_STATUS__POS (0)
118 #define LTR568_ALS_STATUS_REG_ALS_DATA_STATUS__MSK (0x01)
119 #define LTR568_ALS_STATUS_REG_ALS_DATA_STATUS__REG (LTR568_ALS_STATUS)
120
121 #define LTR568_ALS_STATUS_REG_ALS_INT_STATUS__POS (1)
122 #define LTR568_ALS_STATUS_REG_ALS_INT_STATUS__MSK (0x02)
123 #define LTR568_ALS_STATUS_REG_ALS_INT_STATUS__REG (LTR568_ALS_STATUS)
124
125 #define LTR568_ALS_STATUS_REG_ALS_GAIN__POS (3)
126 #define LTR568_ALS_STATUS_REG_ALS_GAIN__MSK (0x78)
127 #define LTR568_ALS_STATUS_REG_ALS_GAIN__REG (LTR568_ALS_STATUS)
128
129 #define LTR568_ALS_STATUS_REG_DATA_VALIDITY__POS (7)
130 #define LTR568_ALS_STATUS_REG_DATA_VALIDITY__MSK (0x80)
131 #define LTR568_ALS_STATUS_REG_DATA_VALIDITY__REG (LTR568_ALS_STATUS)
132
133 #define LTR568_PS_STATUS_REG_PS_DATA_STATUS__POS (0)
134 #define LTR568_PS_STATUS_REG_PS_DATA_STATUS__MSK (0x01)
135 #define LTR568_PS_STATUS_REG_PS_DATA_STATUS__REG (LTR568_PS_STATUS)
136
137 #define LTR568_PS_STATUS_REG_PS_INT_STATUS__POS (1)
138 #define LTR568_PS_STATUS_REG_PS_INT_STATUS__MSK (0x02)
139 #define LTR568_PS_STATUS_REG_PS_INT_STATUS__REG (LTR568_PS_STATUS)
140
141 #define LTR568_PS_STATUS_REG_AMBIENT_SAT__POS (2)
142 #define LTR568_PS_STATUS_REG_AMBIENT_SAT__MSK (0x04)
143 #define LTR568_PS_STATUS_REG_AMBIENT_SAT__REG (LTR568_PS_STATUS)
144
145 #define LTR568_PS_STATUS_REG_NTF__POS (4)
146 #define LTR568_PS_STATUS_REG_NTF__MSK (0x10)
147 #define LTR568_PS_STATUS_REG_NTF__REG (LTR568_PS_STATUS)
148
149 #define LTR568_PS_STATUS_REG_FTN__POS (5)
150 #define LTR568_PS_STATUS_REG_FTN__MSK (0x20)
151 #define LTR568_PS_STATUS_REG_FTN__REG (LTR568_PS_STATUS)
152
153 #define LTR568_INTERRUPT_REG_INT_MODE__POS (0)
154 #define LTR568_INTERRUPT_REG_INT_MODE__MSK (0x03)
155 #define LTR568_INTERRUPT_REG_INT_MODE__REG (LTR568_INTERRUPT)
156
157 #define LTR568_INTERRUPT_REG_INT_POLARITY__POS (2)
158 #define LTR568_INTERRUPT_REG_INT_POLARITY__MSK (0x04)
159 #define LTR568_INTERRUPT_REG_INT_POLARITY__REG (LTR568_INTERRUPT)
160
161 #define LTR568_INTR_PRST_REG_ALS_PERSIST__POS (0)
162 #define LTR568_INTR_PRST_REG_ALS_PERSIST__MSK (0x0F)
163 #define LTR568_INTR_PRST_REG_ALS_PERSIST__REG (LTR568_INTR_PRST)
164
165 #define LTR568_INTR_PRST_REG_PS_PERSIST__POS (4)
166 #define LTR568_INTR_PRST_REG_PS_PERSIST__MSK (0xF0)
167 #define LTR568_INTR_PRST_REG_PS_PERSIST__REG (LTR568_INTR_PRST)
168
169 #define LTR568_GET_BITSLICE(regvar, bitname) ((regvar & LTR568_##bitname##__MSK) >> LTR568_##bitname##__POS)
170 #define LTR568_SET_BITSLICE(regvar, bitname, val) ((regvar & ~LTR568_##bitname##__MSK) | ((val<<LTR568_##bitname##__POS)<R568_##bitname##__MSK))
171
172 #define LTR568_WAIT_TIME_PER_CHECK (10)
173 #define LTR568_WAIT_TIME_TOTAL (100)
174
175 typedef enum {
176 LTR568_ALS_AVE_LIMIT_511 = 0x00,
177 LTR568_ALS_AVE_LIMIT_255 = 0x01,
178 LTR568_ALS_AVE_LIMIT_127 = 0x02,
179 } LTR568_CFG_ALS_AVE_LIMIT;
180
181 typedef enum {
182 LTR568_ALS_STANDBY = 0x00,
183 LTR568_ALS_ACTIVE = 0x01,
184 } LTR568_CFG_ALS_MODE;
185
186 typedef enum {
187 LTR568_ALS_SAR_ENABLE = 0x00,
188 LTR568_ALS_SAR_DISABLE = 0x01,
189 } LTR568_CFG_ALS_SAR_ENB;
190
191 typedef enum {
192 LTR568_ALS_GAIN_1X = 0x00,
193 LTR568_ALS_GAIN_4X = 0x01,
194 LTR568_ALS_GAIN_16X = 0x02,
195 LTR568_ALS_GAIN_64X = 0x03,
196 LTR568_ALS_GAIN_128X = 0x04,
197 LTR568_ALS_GAIN_512X = 0x05,
198 } LTR568_CFG_ALS_Gain;
199
200 typedef enum {
201 LTR568_IR_DISABLE = 0x00,
202 LTR568_IR_ENABLE = 0x01,
203 } LTR568_CFG_IR_EN;
204
205 typedef enum {
206 LTR568_ALS_RES_16BIT = 0x00,
207 LTR568_ALS_RES_15BIT = 0x01,
208 LTR568_ALS_RES_14BIT = 0x02,
209 LTR568_ALS_RES_13BIT = 0x03,
210 } LTR568_CFG_ALS_RESOLUTION;
211
212 typedef enum {
213 LTR568_SW_RESET_FALSE = 0x00,
214 LTR568_SW_RESET_TRUE = 0x01,
215 } LTR568_CFG_SW_RESET;
216
217 typedef enum {
218 LTR568_PS_STANDBY = 0x00,
219 LTR568_PS_ACTIVE = 0x01,
220 } LTR568_CFG_PS_MODE;
221
222 typedef enum {
223 LTR568_FTN_NTF_DISABLE = 0x00,
224 LTR568_FTN_NTF_ENABLE = 0x01,
225 } LTR568_CFG_FTN_NTF_EN;
226
227 typedef enum {
228 LTR568_PS_OS_DISABLE = 0x00,
229 LTR568_PS_OS_ENABLE = 0x01,
230 } LTR568_CFG_PS_OS;
231
232 typedef enum {
233 LTR568_PS_LED_CURRENT_0mA = 0x00,
234 LTR568_PS_LED_CURRENT_50mA = 0x01,
235 LTR568_PS_LED_CURRENT_100mA = 0x02,
236 LTR568_PS_LED_CURRENT_120mA = 0x03,
237 LTR568_PS_LED_CURRENT_140mA = 0x04,
238 LTR568_PS_LED_CURRENT_170mA = 0x05,
239 LTR568_PS_LED_CURRENT_190mA = 0x06,
240 LTR568_PS_LED_CURRENT_240mA = 0x07,
241 } LTR568_CFG_PS_LED_CURRENT;
242
243 typedef enum {
244 LTR568_PS_PULSE_WIDTH_4us = 0x00,
245 LTR568_PS_PULSE_WIDTH_8us = 0x01,
246 LTR568_PS_PULSE_WIDTH_16us = 0x02,
247 LTR568_PS_PULSE_WIDTH_32us = 0x03,
248 } LTR568_CFG_PS_LED_PULSE_WIDTH;
249
250 typedef enum {
251 LTR568_PS_PULSE_DUTY_12_5PCT = 0x00,
252 LTR568_PS_PULSE_DUTY_25PCT = 0x01,
253 LTR568_PS_PULSE_DUTY_50PCT = 0x02,
254 LTR568_PS_PULSE_DUTY_100PCT = 0x03,
255 } LTR568_CFG_PS_LED_PULSE_DUTY;
256
257 typedef enum {
258 LTR568_PS_AVE_FAC_0n = 0x00,
259 LTR568_PS_AVE_FAC_2n = 0x01,
260 LTR568_PS_AVE_FAC_4n = 0x02,
261 LTR568_PS_AVE_FAC_5n = 0x03,
262 } LTR568_CFG_PS_AVE_FAC;
263
264 typedef enum {
265 LTR568_PS_MEAS_RATE_6_125 = 0x00, /* PS Measurement Repeat Rate = 6.125ms */
266 LTR568_PS_MEAS_RATE_12_5 = 0x01, /* PS Measurement Repeat Rate = 12.5ms */
267 LTR568_PS_MEAS_RATE_25 = 0x02, /* PS Measurement Repeat Rate = 25ms */
268 LTR568_PS_MEAS_RATE_50 = 0x03, /* PS Measurement Repeat Rate = 50ms */
269 LTR568_PS_MEAS_RATE_100 = 0x04, /* PS Measurement Repeat Rate = 100ms (default) */
270 LTR568_PS_MEAS_RATE_200 = 0x05, /* PS Measurement Repeat Rate = 200ms */
271 LTR568_PS_MEAS_RATE_400 = 0x06, /* PS Measurement Repeat Rate = 400ms */
272 LTR568_PS_MEAS_RATE_800 = 0x07, /* PS Measurement Repeat Rate = 800ms */
273 } LTR568_CFG_PS_MEAS_RATE;
274
275 typedef enum {
276 LTR568_ALS_MEAS_RATE_100 = 0x00, /* ALS Measurement Repeat Rate = 100ms */
277 LTR568_ALS_MEAS_RATE_200 = 0x01, /* ALS Measurement Repeat Rate = 200ms */
278 LTR568_ALS_MEAS_RATE_400 = 0x02, /* ALS Measurement Repeat Rate = 400ms (default) */
279 LTR568_ALS_MEAS_RATE_800 = 0x03, /* ALS Measurement Repeat Rate = 800ms */
280 } LTR568_CFG_ALS_MEAS_RATE;
281
282
283 typedef enum {
284 LTR568_ALS_INT_TIME_50 = 0x00, /* ALS Measurement Repeat Rate = 50ms */
285 LTR568_ALS_INT_TIME_100 = 0x01, /* ALS Measurement Repeat Rate = 100ms (default) */
286 LTR568_ALS_INT_TIME_200 = 0x02, /* ALS Measurement Repeat Rate = 200ms */
287 LTR568_ALS_INT_TIME_400 = 0x03, /* ALS Measurement Repeat Rate = 400ms */
288 } LTR568_CFG_ALS_INT_TIME;
289
290 typedef enum {
291 LTR568_ALS_DATA_STATUS_OLD = 0x00,
292 LTR568_ALS_DATA_STATUS_NEW = 0x01,
293 } LTR568_CFG_ALS_DATA_STATUS;
294
295 typedef enum {
296 LTR568_ALS_INT_FALSE = 0x00,
297 LTR568_ALS_INT_TRUE = 0x01,
298 } LTR568_CFG_ALS_INT_STATUS;
299
300 typedef enum {
301 LTR568_ALS_DATA_VALID = 0x00,
302 LTR568_ALS_DATA_INVALID = 0x01,
303 } LTR568_CFG_ALS_DATA_VALIDITY;
304
305 typedef enum {
306 LTR568_PS_DATA_STATUS_OLD = 0x00,
307 LTR568_PS_DATA_STATUS_NEW = 0x01,
308 } LTR568_CFG_PS_DATA_STATUS;
309
310 typedef enum {
311 LTR568_PS_INT_FALSE = 0x00,
312 LTR568_PS_INT_TRUE = 0x01,
313 } LTR568_CFG_PS_INT_STATUS;
314
315 typedef enum {
316 LTR568_PS_AMBIENT_SAT_FALSE = 0x00,
317 LTR568_PS_AMBIENT_SAT_TRUE = 0x01,
318 } LTR568_CFG_PS_AMBIENT_SAT_STATUS;
319
320 typedef enum {
321 LTR568_PS_NTF_FALSE = 0x00,
322 LTR568_PS_NTF_TRUE = 0x01,
323 } LTR568_CFG_PS_NTF_STATUS;
324
325 typedef enum {
326 LTR568_PS_FTN_FALSE = 0x00,
327 LTR568_PS_FTN_TRUE = 0x01,
328 } LTR568_CFG_PS_FTN_STATUS;
329
330 typedef enum {
331 LTR568_INT_INACTIVE = 0x00,
332 LTR568_INT_PS = 0x01,
333 LTR568_INT_ALS = 0x02,
334 LTR568_INT_ALS_PS = 0x02,
335 } LTR568_CFG_INT_MODE;
336
337 typedef enum {
338 LTR568_INT_ACTIVE_LO = 0x00,
339 LTR568_INT_ACTIVE_HI = 0x01,
340 } LTR568_CFG_INT_POLARITY;
341
342 typedef enum {
343 LTR568_FLAG_INIT_ALS = 0,
344 LTR568_FLAG_INIT_PS,
345 LTR568_FLAG_INIT_RGB,
346 } LTR568_FLAG_INIT_BIT;
347
348 i2c_dev_t ltr568_ctx = {
349 .port = 3,
350 .config.address_width = 8,
351 .config.freq = 100000,
352 .config.dev_addr = LTR568_I2C_ADDR,
353 };
354
355 static uint8_t g_init_bitwise = 0;
356
drv_als_ps_liteon_ltr568_validate_id(i2c_dev_t * drv,uint8_t part_id,uint8_t manufac_id)357 static int drv_als_ps_liteon_ltr568_validate_id(i2c_dev_t* drv, uint8_t part_id, uint8_t manufac_id)
358 {
359 int ret = 0;
360 uint8_t part_id_value = 0;
361 uint8_t manufac_id_value = 0;
362
363 if (drv == NULL) {
364 return -1;
365 }
366
367 ret = sensor_i2c_read(drv, LTR568_PART_ID, &part_id_value, I2C_DATA_LEN, I2C_OP_RETRIES);
368 if (unlikely(ret)) {
369 return ret;
370 }
371
372 ret = sensor_i2c_read(drv, LTR568_MANUFAC_ID, &manufac_id_value, I2C_DATA_LEN, I2C_OP_RETRIES);
373 if (unlikely(ret)) {
374 return ret;
375 }
376
377 if (part_id_value != part_id || manufac_id_value != manufac_id) {
378 return -1;
379 }
380
381 return 0;
382 }
383
drv_als_liteon_ltr568_set_power_mode(i2c_dev_t * drv,dev_power_mode_e mode)384 static int drv_als_liteon_ltr568_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
385 {
386 int ret = 0;
387 uint8_t dev_mode = 0;
388 uint8_t value = 0;
389
390 ret = sensor_i2c_read(drv, LTR568_ALS_CONTR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
391 if (unlikely(ret)) {
392 return ret;
393 }
394
395 switch (mode) {
396 case DEV_POWER_OFF:
397 case DEV_SLEEP:
398 dev_mode = LTR568_SET_BITSLICE(value, ALS_CONTR_REG_ALS_MODE, LTR568_ALS_STANDBY);
399 break;
400 case DEV_POWER_ON:
401 dev_mode = LTR568_SET_BITSLICE(value, ALS_CONTR_REG_ALS_MODE, LTR568_ALS_ACTIVE);
402 break;
403 default:
404 return -1;
405 }
406
407 ret = sensor_i2c_write(drv, LTR568_ALS_CONTR, &dev_mode, I2C_DATA_LEN, I2C_OP_RETRIES);
408 if (unlikely(ret)) {
409 return ret;
410 }
411
412 return 0;
413 }
414
drv_ps_liteon_ltr568_set_power_mode(i2c_dev_t * drv,dev_power_mode_e mode)415 static int drv_ps_liteon_ltr568_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
416 {
417 int ret = 0;
418 uint8_t dev_mode = 0;
419 uint8_t value = 0;
420
421 ret = sensor_i2c_read(drv, LTR568_PS_CONTR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
422 if (unlikely(ret)) {
423 return ret;
424 }
425
426 switch (mode) {
427 case DEV_POWER_OFF:
428 case DEV_SLEEP:
429 dev_mode = LTR568_SET_BITSLICE(value, PS_CONTR_REG_PS_MODE, LTR568_PS_STANDBY);
430 break;
431 case DEV_POWER_ON:
432 dev_mode = LTR568_SET_BITSLICE(value, PS_CONTR_REG_PS_MODE, LTR568_PS_ACTIVE);
433 break;
434 default:
435 return -1;
436 }
437
438 ret = sensor_i2c_write(drv, LTR568_PS_CONTR, &dev_mode, I2C_DATA_LEN, I2C_OP_RETRIES);
439 if (unlikely(ret)) {
440 return ret;
441 }
442
443 return 0;
444 }
445
drv_als_liteon_ltr568_is_ready(i2c_dev_t * drv)446 UNUSED static int drv_als_liteon_ltr568_is_ready(i2c_dev_t* drv)
447 {
448 int ret = 0;
449 uint8_t value = 0;
450
451 ret = sensor_i2c_read(drv, LTR568_ALS_STATUS, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
452 if (unlikely(ret)) {
453 return 0;
454 }
455
456 ret = (LTR568_GET_BITSLICE(value, ALS_STATUS_REG_ALS_DATA_STATUS) == LTR568_ALS_DATA_STATUS_NEW) ? 1 : 0;
457
458 return ret;
459 }
460
drv_ps_liteon_ltr568_is_ready(i2c_dev_t * drv)461 UNUSED static int drv_ps_liteon_ltr568_is_ready(i2c_dev_t* drv)
462 {
463 int ret = 0;
464 uint8_t value = 0;
465
466 ret = sensor_i2c_read(drv, LTR568_PS_STATUS, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
467 if (unlikely(ret)) {
468 return 0;
469 }
470
471 ret = (LTR568_GET_BITSLICE(value, PS_STATUS_REG_PS_DATA_STATUS) == LTR568_PS_DATA_STATUS_NEW) ? 1 : 0;
472
473 return ret;
474 }
475
drv_als_liteon_ltr568_set_default_config(i2c_dev_t * drv)476 static int drv_als_liteon_ltr568_set_default_config(i2c_dev_t* drv)
477 {
478 int ret = 0;
479 uint8_t value = 0;
480
481 value = LTR568_SET_BITSLICE(value, ALS_AVE_LIMIT_REG_ALS_AVE_LIMIT, LTR568_ALS_AVE_LIMIT_255);
482 ret = sensor_i2c_write(drv, LTR568_ALS_AVE_LIMIT, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
483 if (unlikely(ret)) {
484 return ret;
485 }
486
487 value = 0;
488 ret = sensor_i2c_write(drv, LTR568_ALS_AVE_FAC, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
489 if (unlikely(ret)) {
490 return ret;
491 }
492
493 ret = sensor_i2c_read(drv, LTR568_ALS_CONTR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
494 if (unlikely(ret)) {
495 return ret;
496 }
497 value = LTR568_SET_BITSLICE(value, ALS_CONTR_REG_ALS_SAR, LTR568_ALS_SAR_DISABLE);
498 value = LTR568_SET_BITSLICE(value, ALS_CONTR_REG_ALS_GAIN, LTR568_ALS_GAIN_1X);
499 value = LTR568_SET_BITSLICE(value, ALS_CONTR_REG_IR_EN, LTR568_IR_ENABLE);
500 value = LTR568_SET_BITSLICE(value, ALS_CONTR_REG_ALS_RES, LTR568_ALS_RES_16BIT);
501 ret = sensor_i2c_write(drv, LTR568_ALS_CONTR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
502 if (unlikely(ret)) {
503 return ret;
504 }
505
506 value = 0;
507 value = LTR568_SET_BITSLICE(value, ALS_INT_TIME_REG_MEAS_RATE, LTR568_ALS_MEAS_RATE_400);
508 value = LTR568_SET_BITSLICE(value, ALS_INT_TIME_REG_INTEG_TIME, LTR568_ALS_INT_TIME_100);
509 ret = sensor_i2c_write(drv, LTR568_ALS_INT_TIME, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
510 if (unlikely(ret)) {
511 return ret;
512 }
513
514 return 0;
515 }
516
drv_ps_liteon_ltr568_set_default_config(i2c_dev_t * drv)517 static int drv_ps_liteon_ltr568_set_default_config(i2c_dev_t* drv)
518 {
519 int ret = 0;
520 uint8_t value = 0;
521
522 ret = sensor_i2c_read(drv, LTR568_PS_CONTR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
523 if (unlikely(ret)) {
524 return ret;
525 }
526 value = LTR568_SET_BITSLICE(value, PS_CONTR_REG_FTN_NTF_EN, LTR568_FTN_NTF_DISABLE);
527 value = LTR568_SET_BITSLICE(value, PS_CONTR_REG_PS_OS, LTR568_PS_OS_DISABLE);
528 ret = sensor_i2c_write(drv, LTR568_PS_CONTR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
529 if (unlikely(ret)) {
530 return ret;
531 }
532
533 value = 0;
534 value = LTR568_SET_BITSLICE(value, PS_LED_REG_LED_CURR, LTR568_PS_LED_CURRENT_100mA);
535 value = LTR568_SET_BITSLICE(value, PS_LED_REG_PULSE_WIDTH, LTR568_PS_PULSE_WIDTH_32us);
536 value = LTR568_SET_BITSLICE(value, PS_LED_REG_PULSE_DUTY, LTR568_PS_PULSE_DUTY_100PCT);
537 ret = sensor_i2c_write(drv, LTR568_PS_LED, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
538 if (unlikely(ret)) {
539 return ret;
540 }
541
542 value = 0;
543 value = LTR568_SET_BITSLICE(value, PS_N_PULSES_REG_PULSE_COUNT, 0);
544 value = LTR568_SET_BITSLICE(value, PS_N_PULSES_REG_PS_AVE_FAC, LTR568_PS_AVE_FAC_0n);
545 ret = sensor_i2c_write(drv, LTR568_PS_N_PULSES, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
546 if (unlikely(ret)) {
547 return ret;
548 }
549
550 value = 0;
551 value = LTR568_SET_BITSLICE(value, PS_MEAS_RATE_REG_MEAS_RATE, LTR568_PS_MEAS_RATE_100);
552 ret = sensor_i2c_write(drv, LTR568_PS_MEAS_RATE, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
553 if (unlikely(ret)) {
554 return ret;
555 }
556
557 return 0;
558 }
559
drv_als_liteon_ltr568_irq_handle(void)560 static void drv_als_liteon_ltr568_irq_handle(void)
561 {
562 /* no handle so far */
563 }
564
drv_als_liteon_ltr568_open(void)565 static int drv_als_liteon_ltr568_open(void)
566 {
567 int ret = 0;
568
569 ret = drv_als_liteon_ltr568_set_power_mode(<r568_ctx, DEV_POWER_ON);
570 if (unlikely(ret)) {
571 return -1;
572 }
573
574 LOG("%s %s successfully \n", SENSOR_STR, __func__);
575 return 0;
576 }
577
drv_als_liteon_ltr568_close(void)578 static int drv_als_liteon_ltr568_close(void)
579 {
580 int ret = 0;
581
582 ret = drv_als_liteon_ltr568_set_power_mode(<r568_ctx, DEV_POWER_OFF);
583 if (unlikely(ret)) {
584 return -1;
585 }
586
587 LOG("%s %s successfully \n", SENSOR_STR, __func__);
588 return 0;
589 }
590
drv_als_liteon_ltr568_get_gain_val(i2c_dev_t * drv)591 static uint16_t drv_als_liteon_ltr568_get_gain_val(i2c_dev_t* drv)
592 {
593 uint16_t als_gain = 0, als_gain_val = 0;
594 bool ret = false;
595
596 ret = sensor_i2c_read(drv, LTR568_ALS_STATUS, (uint8_t*)&als_gain, I2C_DATA_LEN, I2C_OP_RETRIES);
597 if (!unlikely(ret))
598 {
599 als_gain = LTR568_GET_BITSLICE(als_gain, ALS_STATUS_REG_ALS_GAIN);
600 switch (als_gain)
601 {
602 case LTR568_ALS_GAIN_1X:
603 als_gain_val = 1;
604 break;
605 case LTR568_ALS_GAIN_4X:
606 als_gain_val = 4;
607 break;
608 case LTR568_ALS_GAIN_16X:
609 als_gain_val = 16;
610 break;
611 case LTR568_ALS_GAIN_64X:
612 als_gain_val = 64;
613 break;
614 case LTR568_ALS_GAIN_128X:
615 als_gain_val = 128;
616 break;
617 case LTR568_ALS_GAIN_512X:
618 als_gain_val = 512;
619 break;
620 default:
621 als_gain_val = 1;
622 break;
623 }
624 }
625 else
626 {
627 als_gain_val = 0;
628 }
629
630 return als_gain_val;
631 }
632
drv_als_liteon_ltr568_get_integ_time_val(i2c_dev_t * drv)633 static uint16_t drv_als_liteon_ltr568_get_integ_time_val(i2c_dev_t* drv)
634 {
635 uint16_t als_integ = 0, als_integ_val = 0;
636 bool ret = false;
637
638 ret = sensor_i2c_read(drv, LTR568_ALS_INT_TIME, (uint8_t*)&als_integ, I2C_DATA_LEN, I2C_OP_RETRIES);
639 if (!unlikely(ret))
640 {
641 als_integ = LTR568_GET_BITSLICE(als_integ, ALS_INT_TIME_REG_INTEG_TIME);
642 switch (als_integ)
643 {
644 case LTR568_ALS_INT_TIME_50:
645 als_integ_val = 5;
646 break;
647 case LTR568_ALS_INT_TIME_100:
648 als_integ_val = 10;
649 break;
650 case LTR568_ALS_INT_TIME_200:
651 als_integ_val = 20;
652 break;
653 case LTR568_ALS_INT_TIME_400:
654 als_integ_val = 40;
655 break;
656 default:
657 als_integ_val = 5;
658 break;
659 }
660 }
661 else
662 {
663 als_integ_val = 0;
664 }
665
666 return als_integ_val;
667 }
668
drv_als_liteon_ltr568_read(void * buf,size_t len)669 static int drv_als_liteon_ltr568_read(void *buf, size_t len)
670 {
671 int ret = 0;
672 size_t size;
673 uint8_t ir_data_reg[2] = { 0 };
674 uint8_t als_data_reg[2] = { 0 };
675 uint8_t als_sar = 0;
676 uint16_t als_gain_val = 0, als_integ_time_val = 0;
677 uint32_t als_data = 0;
678 als_data_t * pdata = (als_data_t *) buf;
679
680 if (buf == NULL){
681 return -1;
682 }
683
684 size = sizeof(als_data_t);
685 if (len < size){
686 return -1;
687 }
688
689 ret = sensor_i2c_read(<r568_ctx, LTR568_IR_DATA_LSB, &ir_data_reg[0], I2C_DATA_LEN, I2C_OP_RETRIES);
690 if (unlikely(ret)) {
691 return -1;
692 }
693 ret = sensor_i2c_read(<r568_ctx, LTR568_IR_DATA_MSB, &ir_data_reg[1], I2C_DATA_LEN, I2C_OP_RETRIES);
694 if (unlikely(ret)) {
695 return -1;
696 }
697
698 ret = sensor_i2c_read(<r568_ctx, LTR568_GREEN_DATA_LSB, &als_data_reg[0], I2C_DATA_LEN, I2C_OP_RETRIES);
699 if (unlikely(ret)) {
700 return -1;
701 }
702 ret = sensor_i2c_read(<r568_ctx, LTR568_GREEN_DATA_MSB, &als_data_reg[1], I2C_DATA_LEN, I2C_OP_RETRIES);
703 if (unlikely(ret)) {
704 return -1;
705 }
706
707 ret = sensor_i2c_read(<r568_ctx, LTR568_ALS_SAR, &als_sar, I2C_DATA_LEN, I2C_OP_RETRIES);
708 if (unlikely(ret)) {
709 return -1;
710 }
711
712 als_data = ((uint32_t) als_data_reg[1] << 8 | als_data_reg[0]);
713 als_gain_val = drv_als_liteon_ltr568_get_gain_val(<r568_ctx);
714 als_integ_time_val = drv_als_liteon_ltr568_get_integ_time_val(<r568_ctx);
715 if ((als_gain_val != 0) && (als_integ_time_val != 0))
716 {
717 pdata->lux = (als_data * 25) / als_gain_val / als_integ_time_val / 10;
718 }
719 else
720 {
721 pdata->lux = 0;
722 }
723 pdata->timestamp = aos_now_ms();
724
725 return (int) size;
726 }
727
drv_als_liteon_ltr568_write(const void * buf,size_t len)728 static int drv_als_liteon_ltr568_write(const void *buf, size_t len)
729 {
730 (void) buf;
731 (void) len;
732
733 return 0;
734 }
735
drv_als_liteon_ltr568_ioctl(int cmd,unsigned long arg)736 static int drv_als_liteon_ltr568_ioctl(int cmd, unsigned long arg)
737 {
738 int ret = 0;
739
740 switch (cmd) {
741 case SENSOR_IOCTL_SET_POWER: {
742 ret = drv_als_liteon_ltr568_set_power_mode(<r568_ctx, arg);
743 if (unlikely(ret)) {
744 return -1;
745 }
746 } break;
747 case SENSOR_IOCTL_GET_INFO: {
748 /* fill the dev info here */
749 dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
750 info->vendor = DEV_SENSOR_VENDOR_LITEON;
751 info->model = "LTR568";
752 info->unit = lux;
753 } break;
754 default:
755 return -1;
756 }
757
758 LOG("%s %s successfully \n", SENSOR_STR, __func__);
759 return 0;
760 }
761
drv_ps_liteon_ltr568_irq_handle(void)762 static void drv_ps_liteon_ltr568_irq_handle(void)
763 {
764 /* no handle so far */
765 }
766
drv_ps_liteon_ltr568_open(void)767 static int drv_ps_liteon_ltr568_open(void)
768 {
769 int ret = 0;
770
771 ret = drv_ps_liteon_ltr568_set_power_mode(<r568_ctx, DEV_POWER_ON);
772 if (unlikely(ret)) {
773 return -1;
774 }
775
776 LOG("%s %s successfully \n", SENSOR_STR, __func__);
777 return 0;
778
779 }
780
drv_ps_liteon_ltr568_close(void)781 static int drv_ps_liteon_ltr568_close(void)
782 {
783 int ret = 0;
784
785 ret = drv_ps_liteon_ltr568_set_power_mode(<r568_ctx, DEV_POWER_OFF);
786 if (unlikely(ret)) {
787 return -1;
788 }
789
790 LOG("%s %s successfully \n", SENSOR_STR, __func__);
791 return 0;
792 }
793
drv_ps_liteon_ltr568_read(void * buf,size_t len)794 static int drv_ps_liteon_ltr568_read(void *buf, size_t len)
795 {
796 int ret = 0;
797 size_t size;
798 uint8_t reg_data[2] = { 0 };
799 proximity_data_t * pdata = (proximity_data_t *) buf;
800
801 if (buf == NULL) {
802 return -1;
803 }
804
805 size = sizeof(proximity_data_t);
806 if (len < size) {
807 return -1;
808 }
809
810 ret = sensor_i2c_read(<r568_ctx, LTR568_PS_DATA_LSB, ®_data[0], I2C_DATA_LEN, I2C_OP_RETRIES);
811 if (unlikely(ret)) {
812 return -1;
813 }
814 ret = sensor_i2c_read(<r568_ctx, LTR568_PS_DATA_MSB, ®_data[1], I2C_DATA_LEN, I2C_OP_RETRIES);
815 if (unlikely(ret)) {
816 return -1;
817 }
818
819 pdata->present = ((uint32_t) reg_data[1] << 8 | reg_data[0]);
820 pdata->timestamp = aos_now_ms();
821
822 return (int) size;
823 }
824
drv_ps_liteon_ltr568_write(const void * buf,size_t len)825 static int drv_ps_liteon_ltr568_write(const void *buf, size_t len)
826 {
827 (void) buf;
828 (void) len;
829
830 return 0;
831 }
832
drv_ps_liteon_ltr568_ioctl(int cmd,unsigned long arg)833 static int drv_ps_liteon_ltr568_ioctl(int cmd, unsigned long arg)
834 {
835 int ret = 0;
836
837 switch (cmd) {
838 case SENSOR_IOCTL_SET_POWER: {
839 ret = drv_ps_liteon_ltr568_set_power_mode(<r568_ctx, arg);
840 if (unlikely(ret)) {
841 return -1;
842 }
843 } break;
844 case SENSOR_IOCTL_GET_INFO: {
845 /* fill the dev info here */
846 dev_sensor_info_t *info = (dev_sensor_info_t *) arg;
847 info->vendor = DEV_SENSOR_VENDOR_LITEON;
848 info->model = "LTR568";
849 info->unit = cm;
850 } break;
851 default:
852 return -1;
853 }
854
855 LOG("%s %s successfully \n", SENSOR_STR, __func__);
856 return 0;
857 }
858
drv_als_liteon_ltr568_init(void)859 int drv_als_liteon_ltr568_init(void)
860 {
861 int ret = 0;
862 sensor_obj_t sensor_als;
863 memset(&sensor_als, 0, sizeof(sensor_als));
864
865 if (!g_init_bitwise) {
866 ret = drv_als_ps_liteon_ltr568_validate_id(<r568_ctx, LTR568_PART_ID_VAL, LTR568_MANUFAC_ID_VAL);
867 if (unlikely(ret)) {
868 return -1;
869 }
870 }
871
872 if (!(g_init_bitwise & (1 << LTR568_FLAG_INIT_ALS))) {
873 /* fill the sensor_als obj parameters here */
874 sensor_als.path = dev_als_path;
875 sensor_als.tag = TAG_DEV_ALS;
876 sensor_als.io_port = I2C_PORT;
877 sensor_als.mode = DEV_POLLING;
878 sensor_als.power = DEV_POWER_OFF;
879 sensor_als.open = drv_als_liteon_ltr568_open;
880 sensor_als.close = drv_als_liteon_ltr568_close;
881 sensor_als.read = drv_als_liteon_ltr568_read;
882 sensor_als.write = drv_als_liteon_ltr568_write;
883 sensor_als.ioctl = drv_als_liteon_ltr568_ioctl;
884 sensor_als.irq_handle = drv_als_liteon_ltr568_irq_handle;
885
886 ret = sensor_create_obj(&sensor_als);
887 if (unlikely(ret)) {
888 return -1;
889 }
890
891 ret = drv_als_liteon_ltr568_set_default_config(<r568_ctx);
892 if (unlikely(ret)) {
893 return -1;
894 }
895
896 g_init_bitwise |= 1 << LTR568_FLAG_INIT_ALS;
897 }
898
899 LOG("%s %s successfully \n", SENSOR_STR, __func__);
900 return 0;
901 }
902
drv_ps_liteon_ltr568_init(void)903 int drv_ps_liteon_ltr568_init(void)
904 {
905 int ret = 0;
906 sensor_obj_t sensor_ps;
907 memset(&sensor_ps, 0, sizeof(sensor_ps));
908
909 if (!g_init_bitwise) {
910 ret = drv_als_ps_liteon_ltr568_validate_id(<r568_ctx, LTR568_PART_ID_VAL, LTR568_MANUFAC_ID_VAL);
911 if (unlikely(ret)) {
912 return -1;
913 }
914 }
915
916 if (!(g_init_bitwise & (1 << LTR568_FLAG_INIT_PS))) {
917 /* fill the sensor_ps obj parameters here */
918 sensor_ps.tag = TAG_DEV_PS;
919 sensor_ps.path = dev_ps_path;
920 sensor_ps.io_port = I2C_PORT;
921 sensor_ps.mode = DEV_POLLING;
922 sensor_ps.power = DEV_POWER_OFF;
923 sensor_ps.open = drv_ps_liteon_ltr568_open;
924 sensor_ps.close = drv_ps_liteon_ltr568_close;
925 sensor_ps.read = drv_ps_liteon_ltr568_read;
926 sensor_ps.write = drv_ps_liteon_ltr568_write;
927 sensor_ps.ioctl = drv_ps_liteon_ltr568_ioctl;
928 sensor_ps.irq_handle = drv_ps_liteon_ltr568_irq_handle;
929
930 ret = sensor_create_obj(&sensor_ps);
931 if (unlikely(ret)) {
932 return -1;
933 }
934
935 ret = drv_ps_liteon_ltr568_set_default_config(<r568_ctx);
936 if (unlikely(ret)) {
937 return -1;
938 }
939
940 g_init_bitwise |= 1 << LTR568_FLAG_INIT_PS;
941 }
942
943 LOG("%s %s successfully \n", SENSOR_STR, __func__);
944 return 0;
945 }
946
947
948 SENSOR_DRV_ADD(drv_als_liteon_ltr568_init);
949 SENSOR_DRV_ADD(drv_ps_liteon_ltr568_init);
950
951