Lines Matching refs:data
69 #define VCNL4200_PS_DATA 0x08 /* Proximity data */
70 #define VCNL4200_AL_DATA 0x09 /* Ambient light data */
78 #define VCNL4000_AL_RDY BIT(6) /* ALS data ready? */
79 #define VCNL4000_PS_RDY BIT(5) /* proximity data ready? */
104 #define VCNL4010_INT_ALS_EN BIT(2) /* Enable on ALS data ready */
105 #define VCNL4010_INT_PROX_EN BIT(3) /* Enable on proximity data ready */
109 #define VCNL4010_INT_ALS 2 /* ALS data ready */
110 #define VCNL4010_INT_PROXIMITY 3 /* Proximity data ready */
213 int (*init)(struct vcnl4000_data *data);
214 int (*measure_light)(struct vcnl4000_data *data, int *val);
215 int (*measure_proximity)(struct vcnl4000_data *data, int *val);
216 int (*set_power_state)(struct vcnl4000_data *data, bool on);
238 static int vcnl4000_set_power_state(struct vcnl4000_data *data, bool on)
244 static int vcnl4000_init(struct vcnl4000_data *data)
248 ret = i2c_smbus_read_byte_data(data->client, VCNL4000_PROD_REV);
255 if (data->id != VCNL4000)
256 dev_warn(&data->client->dev,
260 if (data->id != VCNL4010)
261 dev_warn(&data->client->dev,
268 data->rev = ret & 0xf;
269 data->al_scale = 250000;
271 return data->chip_spec->set_power_state(data, true);
274 static ssize_t vcnl4000_write_als_enable(struct vcnl4000_data *data, bool en)
278 mutex_lock(&data->vcnl4000_lock);
280 ret = i2c_smbus_read_word_data(data->client, VCNL4200_AL_CONF);
289 ret = i2c_smbus_write_word_data(data->client, VCNL4200_AL_CONF, ret);
292 mutex_unlock(&data->vcnl4000_lock);
297 static ssize_t vcnl4000_write_ps_enable(struct vcnl4000_data *data, bool en)
301 mutex_lock(&data->vcnl4000_lock);
303 ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF1);
312 ret = i2c_smbus_write_word_data(data->client, VCNL4200_PS_CONF1, ret);
315 mutex_unlock(&data->vcnl4000_lock);
320 static int vcnl4200_set_power_state(struct vcnl4000_data *data, bool on)
325 if (!on && (data->ps_int || data->als_int))
328 ret = vcnl4000_write_als_enable(data, on);
332 ret = vcnl4000_write_ps_enable(data, on);
337 /* Wait at least one integration cycle before fetching data */
338 data->vcnl4200_al.last_measurement = ktime_get();
339 data->vcnl4200_ps.last_measurement = ktime_get();
345 static int vcnl4200_init(struct vcnl4000_data *data)
349 ret = i2c_smbus_read_word_data(data->client, VCNL4200_DEV_ID);
356 ret = i2c_smbus_read_word_data(data->client, VCNL4040_DEV_ID);
366 dev_dbg(&data->client->dev, "device id 0x%x", id);
368 data->rev = (ret >> 8) & 0xf;
369 data->ps_int = 0;
370 data->als_int = 0;
372 data->vcnl4200_al.reg = VCNL4200_AL_DATA;
373 data->vcnl4200_ps.reg = VCNL4200_PS_DATA;
377 data->vcnl4200_al.sampling_rate = ktime_set(0, 60000 * 1000);
379 data->vcnl4200_ps.sampling_rate = ktime_set(0, 5760 * 1000);
383 data->vcnl4200_al.sampling_rate = ktime_set(0, 96000 * 1000);
385 data->vcnl4200_ps.sampling_rate = ktime_set(0, 6000 * 1000);
388 data->al_scale = data->chip_spec->ulux_step;
389 mutex_init(&data->vcnl4200_al.lock);
390 mutex_init(&data->vcnl4200_ps.lock);
392 ret = data->chip_spec->set_power_state(data, true);
399 static int vcnl4000_read_data(struct vcnl4000_data *data, u8 data_reg, int *val)
403 ret = i2c_smbus_read_word_swapped(data->client, data_reg);
411 static int vcnl4000_write_data(struct vcnl4000_data *data, u8 data_reg, int val)
416 return i2c_smbus_write_word_swapped(data->client, data_reg, val);
420 static int vcnl4000_measure(struct vcnl4000_data *data, u8 req_mask,
426 mutex_lock(&data->vcnl4000_lock);
428 ret = i2c_smbus_write_byte_data(data->client, VCNL4000_COMMAND,
433 /* wait for data to become ready */
435 ret = i2c_smbus_read_byte_data(data->client, VCNL4000_COMMAND);
444 dev_err(&data->client->dev,
445 "vcnl4000_measure() failed, data not ready\n");
450 ret = vcnl4000_read_data(data, data_reg, val);
454 mutex_unlock(&data->vcnl4000_lock);
459 mutex_unlock(&data->vcnl4000_lock);
463 static int vcnl4200_measure(struct vcnl4000_data *data,
481 ret = i2c_smbus_read_word_data(data->client, chan->reg);
490 static int vcnl4000_measure_light(struct vcnl4000_data *data, int *val)
492 return vcnl4000_measure(data,
497 static int vcnl4200_measure_light(struct vcnl4000_data *data, int *val)
499 return vcnl4200_measure(data, &data->vcnl4200_al, val);
502 static int vcnl4000_measure_proximity(struct vcnl4000_data *data, int *val)
504 return vcnl4000_measure(data,
509 static int vcnl4200_measure_proximity(struct vcnl4000_data *data, int *val)
511 return vcnl4200_measure(data, &data->vcnl4200_ps, val);
514 static int vcnl4010_read_proxy_samp_freq(struct vcnl4000_data *data, int *val,
519 ret = i2c_smbus_read_byte_data(data->client, VCNL4010_PROX_RATE);
532 static bool vcnl4010_is_in_periodic_mode(struct vcnl4000_data *data)
536 ret = i2c_smbus_read_byte_data(data->client, VCNL4000_COMMAND);
543 static int vcnl4000_set_pm_runtime_state(struct vcnl4000_data *data, bool on)
545 struct device *dev = &data->client->dev;
558 static int vcnl4040_read_als_it(struct vcnl4000_data *data, int *val, int *val2)
562 ret = i2c_smbus_read_word_data(data->client, VCNL4200_AL_CONF);
567 if (ret >= data->chip_spec->num_als_it_times)
570 *val = (*data->chip_spec->als_it_times)[ret][0];
571 *val2 = (*data->chip_spec->als_it_times)[ret][1];
576 static ssize_t vcnl4040_write_als_it(struct vcnl4000_data *data, int val)
582 for (i = 0; i < data->chip_spec->num_als_it_times; i++) {
583 if (val == (*data->chip_spec->als_it_times)[i][1])
587 if (i == data->chip_spec->num_als_it_times)
590 data->vcnl4200_al.sampling_rate = ktime_set(0, val * 1200);
591 data->al_scale = div_u64(mul_u32_u32(data->chip_spec->ulux_step,
592 (*data->chip_spec->als_it_times)[0][1]),
595 mutex_lock(&data->vcnl4000_lock);
597 ret = i2c_smbus_read_word_data(data->client, VCNL4200_AL_CONF);
603 ret = i2c_smbus_write_word_data(data->client,
608 mutex_unlock(&data->vcnl4000_lock);
612 static int vcnl4040_read_ps_it(struct vcnl4000_data *data, int *val, int *val2)
616 ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF1);
622 if (ret >= data->chip_spec->num_ps_it_times)
625 *val = (*data->chip_spec->ps_it_times)[ret][0];
626 *val2 = (*data->chip_spec->ps_it_times)[ret][1];
631 static ssize_t vcnl4040_write_ps_it(struct vcnl4000_data *data, int val)
637 for (i = 0; i < data->chip_spec->num_ps_it_times; i++) {
638 if (val == (*data->chip_spec->ps_it_times)[i][1]) {
647 data->vcnl4200_ps.sampling_rate = ktime_set(0, val * 60 * NSEC_PER_USEC);
649 mutex_lock(&data->vcnl4000_lock);
651 ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF1);
657 ret = i2c_smbus_write_word_data(data->client, VCNL4200_PS_CONF1,
661 mutex_unlock(&data->vcnl4000_lock);
665 static ssize_t vcnl4040_read_als_period(struct vcnl4000_data *data, int *val, int *val2)
670 ret = i2c_smbus_read_word_data(data->client, VCNL4200_AL_CONF);
679 if (it >= data->chip_spec->num_als_it_times)
682 val_c = mul_u32_u32((*data->chip_spec->als_it_times)[it][1],
689 static ssize_t vcnl4040_write_als_period(struct vcnl4000_data *data, int val, int val2)
696 ret = i2c_smbus_read_word_data(data->client, VCNL4200_AL_CONF);
701 if (it >= data->chip_spec->num_als_it_times)
706 (*data->chip_spec->als_it_times)[it][1]))
710 mutex_lock(&data->vcnl4000_lock);
712 ret = i2c_smbus_read_word_data(data->client, VCNL4200_AL_CONF);
718 ret = i2c_smbus_write_word_data(data->client, VCNL4200_AL_CONF,
722 mutex_unlock(&data->vcnl4000_lock);
726 static ssize_t vcnl4040_read_ps_period(struct vcnl4000_data *data, int *val, int *val2)
730 ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF1);
739 if (it >= data->chip_spec->num_ps_it_times)
742 *val = (*data->chip_spec->ps_it_times)[it][0];
743 *val2 = (*data->chip_spec->ps_it_times)[it][1] *
749 static ssize_t vcnl4040_write_ps_period(struct vcnl4000_data *data, int val, int val2)
754 ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF1);
759 if (it >= data->chip_spec->num_ps_it_times)
767 (*data->chip_spec->ps_it_times)[it][1])
772 mutex_lock(&data->vcnl4000_lock);
774 ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF1);
780 ret = i2c_smbus_write_word_data(data->client, VCNL4200_PS_CONF1,
784 mutex_unlock(&data->vcnl4000_lock);
788 static ssize_t vcnl4040_read_ps_oversampling_ratio(struct vcnl4000_data *data, int *val)
792 ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF3);
805 static ssize_t vcnl4040_write_ps_oversampling_ratio(struct vcnl4000_data *data, int val)
819 mutex_lock(&data->vcnl4000_lock);
821 ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF3);
827 ret = i2c_smbus_write_word_data(data->client, VCNL4200_PS_CONF3,
831 mutex_unlock(&data->vcnl4000_lock);
835 static ssize_t vcnl4040_read_ps_calibbias(struct vcnl4000_data *data, int *val, int *val2)
839 ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF3);
853 static ssize_t vcnl4040_write_ps_calibbias(struct vcnl4000_data *data, int val)
867 mutex_lock(&data->vcnl4000_lock);
869 ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF3);
875 ret = i2c_smbus_write_word_data(data->client, VCNL4200_PS_CONF3,
879 mutex_unlock(&data->vcnl4000_lock);
888 struct vcnl4000_data *data = iio_priv(indio_dev);
892 ret = vcnl4000_set_pm_runtime_state(data, true);
898 ret = data->chip_spec->measure_light(data, val);
903 ret = data->chip_spec->measure_proximity(data, val);
910 vcnl4000_set_pm_runtime_state(data, false);
917 *val2 = data->al_scale;
922 ret = vcnl4040_read_als_it(data, val, val2);
925 ret = vcnl4040_read_ps_it(data, val, val2);
936 ret = vcnl4040_read_ps_oversampling_ratio(data, val);
946 ret = vcnl4040_read_ps_calibbias(data, val, val2);
962 struct vcnl4000_data *data = iio_priv(indio_dev);
970 return vcnl4040_write_als_it(data, val2);
972 return vcnl4040_write_ps_it(data, val2);
979 return vcnl4040_write_ps_oversampling_ratio(data, val);
986 return vcnl4040_write_ps_calibbias(data, val2);
1000 struct vcnl4000_data *data = iio_priv(indio_dev);
1006 *vals = (int *)(*data->chip_spec->als_it_times);
1007 *length = 2 * data->chip_spec->num_als_it_times;
1010 *vals = (int *)(*data->chip_spec->ps_it_times);
1011 *length = 2 * data->chip_spec->num_ps_it_times;
1048 struct vcnl4000_data *data = iio_priv(indio_dev);
1058 if (vcnl4010_is_in_periodic_mode(data)) {
1070 ret = vcnl4010_read_proxy_samp_freq(data, val, val2);
1098 static int vcnl4010_write_proxy_samp_freq(struct vcnl4000_data *data, int val,
1115 return i2c_smbus_write_byte_data(data->client, VCNL4010_PROX_RATE,
1124 struct vcnl4000_data *data = iio_priv(indio_dev);
1131 if (vcnl4010_is_in_periodic_mode(data)) {
1140 ret = vcnl4010_write_proxy_samp_freq(data, val, val2);
1164 struct vcnl4000_data *data = iio_priv(indio_dev);
1170 ret = vcnl4000_read_data(data, VCNL4010_HIGH_THR_HI,
1176 ret = vcnl4000_read_data(data, VCNL4010_LOW_THR_HI,
1197 struct vcnl4000_data *data = iio_priv(indio_dev);
1203 ret = vcnl4000_write_data(data, VCNL4010_HIGH_THR_HI,
1209 ret = vcnl4000_write_data(data, VCNL4010_LOW_THR_HI,
1230 struct vcnl4000_data *data = iio_priv(indio_dev);
1236 return vcnl4040_read_als_period(data, val, val2);
1240 ret = i2c_smbus_read_word_data(data->client,
1244 ret = i2c_smbus_read_word_data(data->client,
1258 return vcnl4040_read_ps_period(data, val, val2);
1262 ret = i2c_smbus_read_word_data(data->client,
1266 ret = i2c_smbus_read_word_data(data->client,
1294 struct vcnl4000_data *data = iio_priv(indio_dev);
1300 return vcnl4040_write_als_period(data, val, val2);
1304 ret = i2c_smbus_write_word_data(data->client,
1309 ret = i2c_smbus_write_word_data(data->client,
1324 return vcnl4040_write_ps_period(data, val, val2);
1328 ret = i2c_smbus_write_word_data(data->client,
1333 ret = i2c_smbus_write_word_data(data->client,
1353 static bool vcnl4010_is_thr_enabled(struct vcnl4000_data *data)
1357 ret = i2c_smbus_read_byte_data(data->client, VCNL4010_INT_CTRL);
1369 struct vcnl4000_data *data = iio_priv(indio_dev);
1373 return vcnl4010_is_thr_enabled(data);
1381 struct vcnl4000_data *data = iio_priv(indio_dev);
1391 /* Enable periodic measurement of proximity data. */
1395 * Enable interrupts on threshold, for proximity data by
1400 if (!vcnl4010_is_thr_enabled(data))
1407 ret = i2c_smbus_write_byte_data(data->client, VCNL4000_COMMAND,
1412 ret = i2c_smbus_write_byte_data(data->client, VCNL4010_INT_CTRL, icr);
1441 struct vcnl4000_data *data = iio_priv(indio_dev);
1445 ret = i2c_smbus_read_word_data(data->client, VCNL4200_AL_CONF);
1449 data->als_int = FIELD_GET(VCNL4040_ALS_CONF_INT_EN, ret);
1451 return data->als_int;
1453 ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF1);
1457 data->ps_int = FIELD_GET(VCNL4040_PS_CONF2_PS_INT, ret);
1474 struct vcnl4000_data *data = iio_priv(indio_dev);
1476 mutex_lock(&data->vcnl4000_lock);
1480 ret = i2c_smbus_read_word_data(data->client, VCNL4200_AL_CONF);
1490 data->als_int = FIELD_GET(VCNL4040_ALS_CONF_INT_EN, val);
1491 ret = i2c_smbus_write_word_data(data->client, VCNL4200_AL_CONF,
1495 ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF1);
1506 data->ps_int = FIELD_GET(VCNL4040_PS_CONF2_PS_INT, val);
1507 ret = i2c_smbus_write_word_data(data->client, VCNL4200_PS_CONF1,
1515 mutex_unlock(&data->vcnl4000_lock);
1523 struct vcnl4000_data *data = iio_priv(indio_dev);
1526 ret = i2c_smbus_read_word_data(data->client, data->chip_spec->int_reg);
1570 struct vcnl4000_data *data = iio_priv(indio_dev);
1572 return sprintf(buf, "%u\n", data->near_level);
1578 struct vcnl4000_data *data = iio_priv(indio_dev);
1582 ret = i2c_smbus_read_byte_data(data->client, VCNL4010_ISR);
1609 i2c_smbus_write_byte_data(data->client, VCNL4010_ISR,
1624 struct vcnl4000_data *data = iio_priv(indio_dev);
1632 ret = i2c_smbus_read_byte_data(data->client, VCNL4010_ISR);
1640 ret = vcnl4000_read_data(data,
1651 ret = i2c_smbus_write_byte_data(data->client, VCNL4010_ISR,
1669 struct vcnl4000_data *data = iio_priv(indio_dev);
1674 if (vcnl4010_is_in_periodic_mode(data))
1677 ret = i2c_smbus_write_byte_data(data->client, VCNL4010_INT_CTRL,
1683 return i2c_smbus_write_byte_data(data->client, VCNL4000_COMMAND, cmd);
1688 struct vcnl4000_data *data = iio_priv(indio_dev);
1691 ret = i2c_smbus_write_byte_data(data->client, VCNL4010_INT_CTRL, 0);
1695 return i2c_smbus_write_byte_data(data->client, VCNL4000_COMMAND, 0);
1911 struct vcnl4000_data *data = iio_priv(indio_dev);
1912 struct i2c_client *client = data->client;
1930 struct vcnl4000_data *data;
1934 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
1938 data = iio_priv(indio_dev);
1940 data->client = client;
1941 data->id = id->driver_data;
1942 data->chip_spec = &vcnl4000_chip_spec_cfg[data->id];
1944 mutex_init(&data->vcnl4000_lock);
1946 ret = data->chip_spec->init(data);
1951 data->chip_spec->prod, data->rev);
1954 &data->near_level))
1955 data->near_level = 0;
1957 indio_dev->info = data->chip_spec->info;
1958 indio_dev->channels = data->chip_spec->channels;
1959 indio_dev->num_channels = data->chip_spec->num_channels;
1963 if (data->chip_spec->trig_buffer_func &&
1964 data->chip_spec->buffer_setup_ops) {
1967 data->chip_spec->trig_buffer_func,
1968 data->chip_spec->buffer_setup_ops);
1976 if (client->irq && data->chip_spec->irq_thread) {
1978 NULL, data->chip_spec->irq_thread,
2007 data->chip_spec->set_power_state(data, false);
2014 .data = (void *)VCNL4000,
2018 .data = (void *)VCNL4010,
2022 .data = (void *)VCNL4010,
2026 .data = (void *)VCNL4040,
2030 .data = (void *)VCNL4200,
2039 struct vcnl4000_data *data = iio_priv(indio_dev);
2047 ret = data->chip_spec->set_power_state(data, false);
2056 struct vcnl4000_data *data = iio_priv(indio_dev);
2058 return data->chip_spec->set_power_state(data, false);
2064 struct vcnl4000_data *data = iio_priv(indio_dev);
2066 return data->chip_spec->set_power_state(data, true);