Lines Matching +full:rx +full:- +full:level +full:- +full:trig
1 // SPDX-License-Identifier: GPL-2.0
24 * The PENIRQ of TSC2046 controller is implemented as level shifter attached to
25 * the X+ line. If voltage of the X+ line reaches a specific level the IRQ will
29 * - rate limiting:
31 * - hrtimer:
61 * conversion has 12-bit resolution, whereas with this bit high, the next
62 * conversion has 8-bit resolution. This driver is optimized for 12-bit mode.
68 * SER/DFR - The SER/DFR bit controls the reference mode, either single-ended
75 * auto-wake/suspend mode. In most case this bits should stay zero.
97 * Command transmitted to the controller. This field is empty on the RX
110 /* Group offset within the SPI RX buffer */
147 struct iio_trigger *trig;
166 * in this case the l[] and tx/rx buffer will be out of sync to each
171 struct tsc2046_adc_atom *rx;
231 bit_count = DIV_ROUND_UP(time * NSEC_PER_USEC, priv->time_per_bit_ns);
234 dev_dbg(&priv->spi->dev, "Effective speed %u, time per bit: %u, count bits: %u, count samples: %u\n",
235 priv->effective_speed_hz, priv->time_per_bit_ns,
261 if (priv->internal_vref)
270 return FIELD_GET(TI_TSC2046_DATA_12BIT, get_unaligned_be16(&buf->data));
276 struct tsc2046_adc_ch_cfg *ch = &priv->ch_cfg[ch_idx];
284 count_skip = tsc2046_adc_time_to_count(priv, ch->settling_time_us);
285 max_count = count_skip + ch->oversampling_ratio;
291 return -ENOSPC;
297 return -ENOMEM;
303 return -ENOMEM;
311 for (i = 0; i < max_count - 1; i++)
327 ret = spi_sync(priv->spi, &msg);
329 dev_err_ratelimited(&priv->spi->dev, "SPI transfer failed %pe\n",
337 for (i = 0; i < max_count - count_skip; i++) {
342 return DIV_ROUND_UP(val_normalized, max_count - count_skip);
349 struct tsc2046_adc_ch_cfg *ch = &priv->ch_cfg[ch_idx];
355 offset = priv->l[group - 1].offset + priv->l[group - 1].count;
357 count_skip = tsc2046_adc_time_to_count(priv, ch->settling_time_us);
358 max_count = count_skip + ch->oversampling_ratio;
360 cur = &priv->l[group];
361 cur->offset = offset;
362 cur->count = max_count;
363 cur->skip = count_skip;
365 return sizeof(*priv->tx) * max_count;
371 struct tsc2046_adc_group_layout *l = &priv->l[group];
381 for (i = 0; i < l->count - 1; i++)
382 priv->tx[l->offset + i].cmd = cmd;
385 priv->tx[l->offset + i].cmd = tsc2046_adc_get_cmd(priv, ch_idx, false);
394 l = &priv->l[group];
395 valid_count = l->count - l->skip;
398 val = tsc2046_adc_get_value(&priv->rx[l->offset + l->skip + i]);
408 struct device *dev = &priv->spi->dev;
412 ret = spi_sync(priv->spi, &priv->msg);
418 for (group = 0; group < priv->groups; group++)
419 priv->scan_buf.data[group] = tsc2046_adc_get_val(priv, group);
421 ret = iio_push_to_buffers_with_timestamp(indio_dev, &priv->scan_buf,
423 /* If the consumer is kfifo, we may get a EBUSY here - ignore it. */
424 if (ret < 0 && ret != -EBUSY) {
437 struct iio_dev *indio_dev = pf->indio_dev;
440 mutex_lock(&priv->slock);
442 mutex_unlock(&priv->slock);
444 iio_trigger_notify_done(indio_dev->trig);
458 ret = tsc2046_adc_read_one(priv, chan->channel, NULL);
469 * So, it is better to use external voltage-divider driver
472 *val = priv->vref_mv;
473 *val2 = chan->scan_type.realbits;
477 return -EINVAL;
487 mutex_lock(&priv->slock);
490 for_each_set_bit(ch_idx, active_scan_mask, ARRAY_SIZE(priv->l)) {
496 priv->groups = group;
497 priv->xfer.len = size;
498 priv->time_per_scan_us = size * 8 * priv->time_per_bit_ns / NSEC_PER_USEC;
500 if (priv->scan_interval_us < priv->time_per_scan_us)
501 dev_warn(&priv->spi->dev, "The scan interval (%d) is less then calculated scan time (%d)\n",
502 priv->scan_interval_us, priv->time_per_scan_us);
504 mutex_unlock(&priv->slock);
523 * - the interrupt source is based on level shifter attached to the X
527 * - we should do iio_trigger_poll() at some reduced sample rate
528 * - we should still trigger for some amount of time after last
532 spin_lock_irqsave(&priv->state_lock, flags);
533 switch (priv->state) {
535 if (priv->poll_cnt < TI_TSC2046_POLL_CNT) {
536 priv->poll_cnt++;
537 hrtimer_start(&priv->trig_timer,
538 ns_to_ktime(priv->scan_interval_us *
542 if (priv->poll_cnt >= TI_TSC2046_MIN_POLL_CNT) {
543 priv->state = TSC2046_STATE_POLL_IRQ_DISABLE;
544 enable_irq(priv->spi->irq);
546 priv->state = TSC2046_STATE_POLL;
549 priv->state = TSC2046_STATE_STANDBY;
550 enable_irq(priv->spi->irq);
554 disable_irq_nosync(priv->spi->irq);
557 priv->state = TSC2046_STATE_ENABLE_IRQ;
559 iio_trigger_poll(priv->trig);
566 dev_warn(&priv->spi->dev, "Got unexpected state: %i\n",
567 priv->state);
570 spin_unlock_irqrestore(&priv->state_lock, flags);
581 hrtimer_try_to_cancel(&priv->trig_timer);
583 spin_lock_irqsave(&priv->state_lock, flags);
584 if (priv->state != TSC2046_STATE_SHUTDOWN) {
585 priv->state = TSC2046_STATE_ENABLE_IRQ;
586 priv->poll_cnt = 0;
589 disable_irq_nosync(priv->spi->irq);
590 iio_trigger_poll(priv->trig);
592 spin_unlock_irqrestore(&priv->state_lock, flags);
597 static void tsc2046_adc_reenable_trigger(struct iio_trigger *trig)
599 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
608 tim = ns_to_ktime((priv->scan_interval_us - priv->time_per_scan_us) *
610 hrtimer_start(&priv->trig_timer, tim, HRTIMER_MODE_REL_SOFT);
613 static int tsc2046_adc_set_trigger_state(struct iio_trigger *trig, bool enable)
615 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
620 spin_lock_irqsave(&priv->state_lock, flags);
621 if (priv->state == TSC2046_STATE_SHUTDOWN) {
622 priv->state = TSC2046_STATE_STANDBY;
623 enable_irq(priv->spi->irq);
625 spin_unlock_irqrestore(&priv->state_lock, flags);
627 spin_lock_irqsave(&priv->state_lock, flags);
629 if (priv->state == TSC2046_STATE_STANDBY ||
630 priv->state == TSC2046_STATE_POLL_IRQ_DISABLE)
631 disable_irq_nosync(priv->spi->irq);
633 priv->state = TSC2046_STATE_SHUTDOWN;
634 spin_unlock_irqrestore(&priv->state_lock, flags);
636 hrtimer_cancel(&priv->trig_timer);
659 &priv->effective_speed_hz);
667 if (!priv->effective_speed_hz)
668 priv->effective_speed_hz = priv->spi->max_speed_hz;
671 priv->scan_interval_us = TI_TSC2046_SAMPLE_INTERVAL_US;
672 priv->time_per_bit_ns = DIV_ROUND_UP(NSEC_PER_SEC,
673 priv->effective_speed_hz);
680 for (ch_idx = 0; ch_idx < ARRAY_SIZE(priv->l); ch_idx++)
684 dev_err(&priv->spi->dev,
685 "Calculated scan buffer is too big. Try to reduce spi-max-frequency, settling-time-us or oversampling-ratio\n");
686 return -ENOSPC;
689 priv->tx = devm_kzalloc(&priv->spi->dev, size, GFP_KERNEL);
690 if (!priv->tx)
691 return -ENOMEM;
693 priv->rx = devm_kzalloc(&priv->spi->dev, size, GFP_KERNEL);
694 if (!priv->rx)
695 return -ENOMEM;
697 priv->xfer.tx_buf = priv->tx;
698 priv->xfer.rx_buf = priv->rx;
699 priv->xfer.len = size;
700 spi_message_init_with_transfers(&priv->msg, &priv->xfer, 1);
708 struct device *dev = &priv->spi->dev;
711 for (i = 0; i < ARRAY_SIZE(priv->ch_cfg); i++) {
712 priv->ch_cfg[i].settling_time_us = 1;
713 priv->ch_cfg[i].oversampling_ratio = 1;
727 if (reg >= ARRAY_SIZE(priv->ch_cfg)) {
729 child, reg, ARRAY_SIZE(priv->ch_cfg));
733 ret = fwnode_property_read_u32(child, "settling-time-us", &stl);
735 priv->ch_cfg[reg].settling_time_us = stl;
737 ret = fwnode_property_read_u32(child, "oversampling-ratio",
740 priv->ch_cfg[reg].oversampling_ratio = overs;
747 struct device *dev = &spi->dev;
750 struct iio_trigger *trig;
753 if (spi->max_speed_hz > TI_TSC2046_MAX_CLK_FREQ) {
755 spi->max_speed_hz, TI_TSC2046_MAX_CLK_FREQ);
756 return -EINVAL;
761 return -EINVAL;
763 spi->bits_per_word = 8;
764 spi->mode &= ~SPI_MODE_X_MASK;
765 spi->mode |= SPI_MODE_0;
772 return -ENOMEM;
775 priv->dcfg = dcfg;
777 priv->spi = spi;
779 indio_dev->name = TI_TSC2046_NAME;
780 indio_dev->modes = INDIO_DIRECT_MODE;
781 indio_dev->channels = dcfg->channels;
782 indio_dev->num_channels = dcfg->num_channels;
783 indio_dev->info = &tsc2046_adc_info;
786 if (ret < 0 && ret != -ENODEV)
789 priv->internal_vref = ret == -ENODEV;
790 priv->vref_mv = priv->internal_vref ? TI_TSC2046_INT_VREF : ret / MILLI;
798 mutex_init(&priv->slock);
800 ret = devm_request_irq(dev, spi->irq, &tsc2046_adc_irq,
801 IRQF_NO_AUTOEN, indio_dev->name, indio_dev);
805 trig = devm_iio_trigger_alloc(dev, "touchscreen-%s", indio_dev->name);
806 if (!trig)
807 return -ENOMEM;
809 priv->trig = trig;
810 iio_trigger_set_drvdata(trig, indio_dev);
811 trig->ops = &tsc2046_adc_trigger_ops;
813 spin_lock_init(&priv->state_lock);
814 priv->state = TSC2046_STATE_SHUTDOWN;
815 hrtimer_init(&priv->trig_timer, CLOCK_MONOTONIC,
817 priv->trig_timer.function = tsc2046_adc_timer;
819 ret = devm_iio_trigger_register(dev, trig);
833 indio_dev->trig = iio_trigger_get(priv->trig);
839 { .compatible = "ti,tsc2046e-adc", .data = &tsc2046_adc_dcfg_tsc2046e },
845 { "tsc2046e-adc", (unsigned long)&tsc2046_adc_dcfg_tsc2046e },