Lines Matching refs:data
30 * The KX022A has FIFO which can store 43 samples of HiRes data from 2
32 * 258 bytes of sample data. The quirk to know is that the amount of bytes in
34 * is that full 258 bytes of data is indicated using the max value 255.
41 /* 3 axis, 2 bytes of data for each of the axis */
172 * protect the data stored/retrieved from this structure from
178 /* 3 x 16bit accel data + timestamp */
190 struct kx022a_data *data = iio_priv(idev);
192 return &data->orientation;
330 static int kx022a_turn_on_off_unlocked(struct kx022a_data *data, bool on)
335 ret = regmap_set_bits(data->regmap, KX022A_REG_CNTL,
338 ret = regmap_clear_bits(data->regmap, KX022A_REG_CNTL,
341 dev_err(data->dev, "Turn %s fail %d\n", str_on_off(on), ret);
347 static int kx022a_turn_off_lock(struct kx022a_data *data)
351 mutex_lock(&data->mutex);
352 ret = kx022a_turn_on_off_unlocked(data, false);
354 mutex_unlock(&data->mutex);
359 static int kx022a_turn_on_unlock(struct kx022a_data *data)
363 ret = kx022a_turn_on_off_unlocked(data, true);
364 mutex_unlock(&data->mutex);
387 struct kx022a_data *data = iio_priv(idev);
415 ret = kx022a_turn_off_lock(data);
419 ret = regmap_update_bits(data->regmap,
422 data->odr_ns = kx022a_odrs[n];
423 kx022a_turn_on_unlock(data);
437 ret = kx022a_turn_off_lock(data);
441 ret = regmap_update_bits(data->regmap, KX022A_REG_CNTL,
444 kx022a_turn_on_unlock(data);
457 static int kx022a_fifo_set_wmi(struct kx022a_data *data)
461 threshold = data->watermark;
463 return regmap_update_bits(data->regmap, KX022A_REG_BUF_CNTL1,
467 static int kx022a_get_axis(struct kx022a_data *data,
473 ret = regmap_bulk_read(data->regmap, chan->address, &data->buffer[0],
478 *val = le16_to_cpu(data->buffer[0]);
487 struct kx022a_data *data = iio_priv(idev);
497 mutex_lock(&data->mutex);
498 ret = kx022a_get_axis(data, chan, val);
499 mutex_unlock(&data->mutex);
506 ret = regmap_read(data->regmap, KX022A_REG_ODCNTL, ®val);
512 dev_err(data->dev, "Invalid ODR\n");
521 ret = regmap_read(data->regmap, KX022A_REG_CNTL, ®val);
535 struct kx022a_data *data = iio_priv(idev);
540 mutex_lock(&data->mutex);
541 data->watermark = val;
542 mutex_unlock(&data->mutex);
552 struct kx022a_data *data = iio_priv(idev);
555 mutex_lock(&data->mutex);
556 state = data->state;
557 mutex_unlock(&data->mutex);
567 struct kx022a_data *data = iio_priv(idev);
570 mutex_lock(&data->mutex);
571 wm = data->watermark;
572 mutex_unlock(&data->mutex);
586 static int kx022a_drop_fifo_contents(struct kx022a_data *data)
597 data->timestamp = 0;
599 return regmap_write(data->regmap, KX022A_REG_BUF_CLEAR, 0x0);
605 struct kx022a_data *data = iio_priv(idev);
606 struct device *dev = regmap_get_device(data->regmap);
614 ret = regmap_read(data->regmap, KX022A_REG_BUF_STATUS_1, &fifo_bytes);
625 dev_warn(data->dev, "Bad FIFO alignment. Data may be corrupt\n");
649 disable_irq(data->irq);
652 data->old_timestamp = data->timestamp;
653 data->timestamp = iio_get_time_ns(idev);
667 if (data->old_timestamp) {
668 sample_period = data->timestamp - data->old_timestamp;
671 sample_period = data->odr_ns;
673 tstamp = data->timestamp - (count - 1) * sample_period;
681 data->timestamp -= (count - samples) * sample_period;
686 ret = regmap_noinc_read(data->regmap, KX022A_REG_BUF_READ,
696 chs = &data->scan.channels[0];
700 iio_push_to_buffers_with_timestamp(idev, &data->scan, tstamp);
709 enable_irq(data->irq);
716 struct kx022a_data *data = iio_priv(idev);
719 mutex_lock(&data->mutex);
721 mutex_unlock(&data->mutex);
737 static int kx022a_set_drdy_irq(struct kx022a_data *data, bool en)
740 return regmap_set_bits(data->regmap, KX022A_REG_CNTL,
743 return regmap_clear_bits(data->regmap, KX022A_REG_CNTL,
747 static int kx022a_prepare_irq_pin(struct kx022a_data *data)
756 ret = regmap_update_bits(data->regmap, data->inc_reg, mask, val);
763 return regmap_set_bits(data->regmap, data->ien_reg, mask);
766 static int kx022a_fifo_disable(struct kx022a_data *data)
770 ret = kx022a_turn_off_lock(data);
774 ret = regmap_clear_bits(data->regmap, data->ien_reg, KX022A_MASK_WMI);
778 ret = regmap_clear_bits(data->regmap, KX022A_REG_BUF_CNTL2,
783 data->state &= ~KX022A_STATE_FIFO;
785 kx022a_drop_fifo_contents(data);
787 return kx022a_turn_on_unlock(data);
790 mutex_unlock(&data->mutex);
797 struct kx022a_data *data = iio_priv(idev);
802 return kx022a_fifo_disable(data);
805 static int kx022a_fifo_enable(struct kx022a_data *data)
809 ret = kx022a_turn_off_lock(data);
814 ret = kx022a_fifo_set_wmi(data);
819 ret = regmap_set_bits(data->regmap, KX022A_REG_BUF_CNTL2,
824 data->state |= KX022A_STATE_FIFO;
825 ret = regmap_set_bits(data->regmap, data->ien_reg,
830 return kx022a_turn_on_unlock(data);
833 mutex_unlock(&data->mutex);
840 struct kx022a_data *data = iio_priv(idev);
843 * If we use data-ready trigger, then the IRQ masks should be handled by
845 * results to the IIO fifo when data-ready triggers.
850 return kx022a_fifo_enable(data);
862 struct kx022a_data *data = iio_priv(idev);
865 ret = regmap_bulk_read(data->regmap, KX022A_REG_XOUT_L, data->buffer,
870 iio_push_to_buffers_with_timestamp(idev, data->buffer, data->timestamp);
877 /* Get timestamps and wake the thread if we need to read data */
881 struct kx022a_data *data = iio_priv(idev);
883 data->old_timestamp = data->timestamp;
884 data->timestamp = iio_get_time_ns(idev);
886 if (data->state & KX022A_STATE_FIFO || data->trigger_enabled)
893 * WMI and data-ready IRQs are acked when results are read. If we add
900 struct kx022a_data *data = iio_priv(idev);
903 mutex_lock(&data->mutex);
905 if (data->trigger_enabled) {
906 iio_trigger_poll_nested(data->trig);
910 if (data->state & KX022A_STATE_FIFO) {
918 mutex_unlock(&data->mutex);
926 struct kx022a_data *data = iio_trigger_get_drvdata(trig);
929 mutex_lock(&data->mutex);
931 if (data->trigger_enabled == state)
934 if (data->state & KX022A_STATE_FIFO) {
935 dev_warn(data->dev, "Can't set trigger when FIFO enabled\n");
940 ret = kx022a_turn_on_off_unlocked(data, false);
944 data->trigger_enabled = state;
945 ret = kx022a_set_drdy_irq(data, state);
949 ret = kx022a_turn_on_off_unlocked(data, true);
952 mutex_unlock(&data->mutex);
961 static int kx022a_chip_init(struct kx022a_data *data)
966 ret = regmap_write(data->regmap, KX022A_REG_CNTL2, KX022A_MASK_SRST);
976 ret = regmap_read_poll_timeout(data->regmap, KX022A_REG_CNTL2, val,
981 dev_err(data->dev, "Sensor reset %s\n",
986 ret = regmap_reinit_cache(data->regmap, &kx022a_regmap);
988 dev_err(data->dev, "Failed to reinit reg cache\n");
992 /* set data res 16bit */
993 ret = regmap_set_bits(data->regmap, KX022A_REG_BUF_CNTL2,
996 dev_err(data->dev, "Failed to set data resolution\n");
1000 return kx022a_prepare_irq_pin(data);
1008 struct kx022a_data *data;
1025 idev = devm_iio_device_alloc(dev, sizeof(*data));
1029 data = iio_priv(idev);
1051 data->inc_reg = KX022A_REG_INC1;
1052 data->ien_reg = KX022A_REG_INC4;
1058 data->inc_reg = KX022A_REG_INC5;
1059 data->ien_reg = KX022A_REG_INC6;
1062 data->regmap = regmap;
1063 data->dev = dev;
1064 data->irq = irq;
1065 data->odr_ns = KX022A_DEFAULT_PERIOD_NS;
1066 mutex_init(&data->mutex);
1076 ret = iio_read_mount_matrix(dev, &data->orientation);
1081 ret = kx022a_turn_off_lock(data);
1085 ret = kx022a_chip_init(data);
1087 mutex_unlock(&data->mutex);
1091 ret = kx022a_turn_on_unlock(data);
1103 return dev_err_probe(data->dev, ret,
1110 data->trig = indio_trig;
1113 iio_trigger_set_drvdata(indio_trig, data);
1119 name = devm_kasprintf(data->dev, GFP_KERNEL, "%s-kx022a",
1120 dev_name(data->dev));
1122 ret = devm_request_threaded_irq(data->dev, irq, kx022a_irq_handler,
1126 return dev_err_probe(data->dev, ret, "Could not request IRQ\n");
1131 return dev_err_probe(data->dev, ret,
1134 ret = devm_iio_device_register(data->dev, idev);