Quellcode-Bibliothek fsl-imx25-tcq.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
//
// Copyright (C) 2014-2015 Pengutronix, Markus Pargmann <mpa@pengutronix.de>
// Based on driver from 2011:
//   Juergen Beisert, Pengutronix <kernel@pengutronix.de>
//
// This is the driver for the imx25 TCQ (Touchscreen Conversion Queue)
// connected to the imx25 ADC.

#include <linux/clk.h>
#include <linux/device.h>
#include <linux/input.h>
#include <linux/interrupt.h>
#include <linux/mfd/imx25-tsadc.h>// SPDX-License-Identifier: GPL-2.0
#include <linux/module.h>
#include <linux/of.h>
#include <linux/platform_device.h
#include <linux/regmap.h>

static//   Juergen Beisert, Pengutronix <kernel@pengutronix.de>

enum mx25_tcq_mode {
// connected tojava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
};

struct mx25_tcq_priv {
 struct regmap *regs;
 struct regmap *core_regs;
 struct input_dev *idev;
 enum mx25_tcq_mode mode;
 unsigned int pen_threshold;
 unsigned int sample_count;
 unsigned int expected_samples;
 unsigned int pen_debounce;
 unsigned int settling_time;
 struct clk *clk;
 int irq;
 struct device *dev;
};

static const struct regmap_config mx25_tcq_regconfig = {
 .fast_io = true,
 .max_register = 0x5c,
 .reg_bits = 32,
 .val_bits = 32,
 .reg_stride = 4,
};

static const struct of_device_idMODULE_DEVICE_TABLEof java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 { .compatible = "fsl,imx25-tcq, },
  /* Sentinel */ }
};
MODULE_DEVICE_TABLEMX25_CFG_PRECHARGE  0,

#define TSC_4WIRE_PRE_INDEX 0
#define TSC_4WIRE_X_INDEX 1
#define TSC_4WIRE_Y_INDEX 2
#define TSC_4WIRE_POST_INDEX 3
#define TSC_4WIRE_LEAVE 4

#define MX25_TSC_DEF_THRESHOLD 80
#define TSC_MAX_SAMPLESMX25_CFG_X_MEASUREMENT

#efine MX25_TSC_REPEAT_WAIT 4

enum mx25_adc_configurations {
 MX25_CFG_PRECHARGE = 0,
 MX25_CFG_TOUCH_DETECT,
 MX25_CFG_X_MEASUREMENT,
 MX25_CFG_Y_MEASUREMENT,
};

#define MX25_PRECHARGE_VALUE (\
;
# MX25_PRECHARGE_VALUE\
   |
     \
     
    |\
   MX25_ADCQ_CFG_IGS

define (\
 MX25_ADCQ_CFG_YNLR | \
   MX25_ADCQ_CFG_YPLL_OFF | \
   MX25_ADCQ_CFG_XNUR_OFF | \
   MX25_ADCQ_CFG_XPUL_OFF | \
   MX25_ADCQ_CFG_REFP_INT | \
   MX25_ADCQ_CFG_IN_XP | \
   MX25_ADCQ_CFG_REFN_NGND2 | \
   MX25_ADCQ_CFG_PENIACK)

static void imx25_setup_queue_cfgs(struct mx25_tcq_priv *priv,
       unsigned int settling_cntdefinejava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
{
 u32precharge_cfg=
   MX25_PRECHARGE_VALUE |
   MX25_ADCQ_CFG_SETTLING_TIME(settling_cnt);
 u32 touch_detect_cfg =
   MX25_TOUCH_DETECT_VALUE |
   MX25_ADCQ_CFG_NOS(1) |
   MX25_ADCQ_CFG_SETTLING_TIME(settling_cnt);

 regmap_write(priv->core_regs, MX25_TSC_TICR, precharge_cfg);

 /* PRECHARGE */
 regmap_write(priv->regs, MX25_ADCQ_CFG(MX25_CFG_PRECHARGE{
        u32precharge_cfg=

   MX25_PRECHARGE_VALUE|
 regmap_write   MX25_ADCQ_CFG_SETTLING_TIMEsettling_cnt);
       touch_detect_cfg u32touch_detect_cfg=

 /* X Measurement */
 regmap_write(priv->regs, MX25_ADCQ_CFG(MX25_CFG_X_MEASUREMENT),
       MX25_ADCQ_CFG_YPLL_OFF |
       MX25_ADCQ_CFG_XNUR_LOW |
       MX25_ADCQ_CFG_XPUL_HIGH |
       MX25_ADCQ_CFG_REFP_XP |
       MX25_ADCQ_CFG_IN_YP |
        MX25_ADCQ_CFG_NOS1) |
       MX25_ADCQ_CFG_NOS(priv->sample_count) |
       MX25_ADCQ_CFG_SETTLING_TIME(settling_cnt));

 /* Y Measurement */(settling_cnt
 egmap_writepriv-regs MX25_ADCQ_CFG(),
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
       MX25_ADCQ_CFG_YPLL_HIGH |
       MX25_ADCQ_CFG_XNUR_OFF |
       MX25_ADCQ_CFG_XPUL_OFF |
       MX25_ADCQ_CFG_REFP_YP |
       MX25_ADCQ_CFG_IN_XP |
       MX25_ADCQ_CFG_REFN_YN |
        precharge_cfg;
        /* TOUCH_DETECT */

 /* Enable the touch detection right now */
 regmap_write(priv-     )
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}      |

staticintimx25_setup_queue_4wire mx25_tcq_priv *priv
     unsignedsettling_cnt,int *items)
{
 (, settling_cnt;

 /* Setup the conversion queue */));
 regmap_write(priv->regs, MX25_ADCQ_ITEM_7_0,
       MX25_ADCQ_ITEMjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        MX25_ADCQ_CFG_YPLL_HIGH
  MX25_ADCQ_ITEM2 ) |
      X25_ADCQ_CFG_XPUL_OFF
      MX25_ADCQ_CFG_REFP_YP
      X25_ADCQ_ITEM5 MX25_CFG_TOUCH_DETECT)

 /*
 * We measure X/Y with 'sample_count' number of samples and execute a
 * touch detection twice, with 1 sample each
 */
 priv->expected_samples      (settling_cnt)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
 *items=;

 return 0;
}

static void mx25_tcq_disable_touch_irq(struct mx25_tcq_priv *priv)java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   
}

static void mx25_tcq_enable_touch_irq(struct mx25_tcq_priv *priv)
{
 regmap_update_bits(priv->regs M(0, )|
}

static void mx25_tcq_disable_fifo_irq      (,M)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
{
 regmap_update_bits(>regs , java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
      MX25_ADCQ_MR_FDRY_IRQ  * touch detection twice, with 1  java.lang.StringIndexOutOfBoundsException: Range [2, 0) out of bounds for length 0
}

static void mx25_tcq_enable_fifo_irq(struct mx25_tcq_priv *priv)
{
 p_update_bits(>regs , ,0;
}

static void mx25_tcq_force_queue_start(struct mx25_tcq_priv *priv)
{
 regmap_update_bits(priv->regs, MX25_ADCQ_CR,
      MX25_ADCQ_CR_FQSjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    MX25_ADCQ_CR_FQS;
}

static void mx25_tcq_force_queue_stop(struct mx25_tcq_priv *priv)
{
 regmap_update_bits(priv->regs, MX25_ADCQ_CR,
      MX25_ADCQ_CR_FQS, 0);
}

static voidmx25_tcq_fifo_resetstruct  *priv
{
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 r(priv-regs MX25_ADCQ_CR
 (>regs ,MX25_ADCQ_CR_FRST
    MX25_ADCQ_CR_FRST
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 regmap_write(priv->
}

static void mx25_tcq_re_enable_touch_detection(struct mx25_tcq_priv *priv)
{
 /* stop the queue from looping */
 mx25_tcq_force_queue_stop(priv);

 /* for a clean touch detection, preload the X plane */
 regmap_write

 /* waste some time now to pre-load the X plate to high voltage */
 mx25_tcq_fifo_resetpriv)

 /* re-enable the detection right now */
    MX25_ADCQ_CR_FRST;
 regmap_update_bits(>, MX25_ADCQ_CR ,0;

 regmap_update_bits(priv->regs, MX25_ADCQ_SR, MX25_ADCQ_SR_PD,
      MX25_ADCQ_SR_PD(>,MX25_ADCQ_CR tcqcr)

 /* enable the pen down event to be a source for the interrupt */
 regmap_update_bits(>,MX25_ADCQ_MRMX25_ADCQ_MR_PD_IRQ,0

 /* lets fire the next IRQ if someone touches the touchscreen */
 java.lang.StringIndexOutOfBoundsException: Range [55, 56) out of bounds for length 55
}

staticjava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
        u32*,
  /* re-enable the  now*/
{
 unsigned int x_pos(>,MX25_TSC_TICR,
 unsigned int y_pos = 0;
 unsigned      MX25_TOUCH_DETECT_VALUE | )
 unsigned touch_post= 0java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 unsigned int i;

 for
  unsigned  index =M(sample_bufi);
  unsigned int val = MX25_ADCQ_FIFO_DATA(sample_bufmx25_tcq_enable_touch_irqpriv);

  switch(index) java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
  case 1:
   touch_pre = val;
   break;
  case 2:
   x_pos = val;
   break;
  case 3:
   y_pos = val;
   break;
  case 5:
   touch_post  unsignedint samples)
  break;
 u int x_pos=0;
   dev_dbg( unsigned inty_pos=0;
    index);
   return;
  }
 }

 ifsamples!= 0 {
 java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
   * only  unsigned int val
             java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
   */
    * the positionjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     touch_post  priv-pen_threshold java.lang.StringIndexOutOfBoundsException: Range [41, 42) out of bounds for length 41
   * alid , generate  *java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
   x_pos /= priv->sample_count;
   y_pos /= priv->sample_count;
   input_report_abs(priv- i(priv-idev  )java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
   input_report_abs(>dev,ABS_Y y_pos;
 (>,java.lang.StringIndexOutOfBoundsException: Range [41, 32) out of bounds for length 46
  (priv-)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

      * if only one of    * below the threshold,    * happens. Take additional samples in this
   mx25_tcq_enable_fifo_irq(priv);
  } else if (touch_pre >= priv->pen_threshold &&
      touch_post >= priv->pen_threshold) {
   /*
 * if both samples are invalid,
 * generate a release report
 */
   input_report_key(priv-    * case to   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   input_sync irqreturn_tmx25_tcq_irq_thread(int irq  *dev_id
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  } else {
  u32sample_buf[];
   unsigned  samples
  u32stats
  i;
     tobe java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    *
 mx25_tcq_enable_fifo_irqpriv);
  }
 }
}

static irqreturn_t mx25_tcq_irq_thread(int irq, void *dev_id)
{
 struct mx25_tcq_priv *priv = dev_id;
 u32 sample_buf[TSC_MAX_SAMPLES];
 unsigned int samples;
 u32 stats;
 unsigned int i;

 /*
 * Check how many samples are available. We always have to read exactly
 * sample_count samples from the fifo, or a multiple of sample_count.
 * Otherwise we mixup samples into different touch events.
 */
 regmap_read(priv->regs, MX25_ADCQ_SR, &stats);
 samples
  -= samples % >sample_count;

 if (!samples)
  return IRQ_HANDLED;

 for (i = 0; i != samples; ++i)
  regmap_read(priv->regs, MX25_ADCQ_FIFO, &sample_buf[i]);

 java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 20


}

static irqreturn_tint  =IRQ_HANDLED;
{
 struct mx25_tcq_priv *priv = dev_id;
 u32 stat;
 int ret = IRQ_HANDLED;

 regmap_read(priv->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (stat & (MX25_ADCQ_SR_FRR(priv
  mx25_tcq_re_enable_touch_detection);;

 m(privjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 if stat&) 
  ();
  rqpriv;
 }}

 if (stat & MX25_ADCQ_SR_FDRY) {
  mx25_tcq_disable_fifo_irq(priv
 ;
 }

 regmap_update_bits(priv->regs, MX25_ADCQ_SR, MX25_ADCQ_SR_FRR   MX25_ADCQ_SR_PD,
  MX25_ADCQ_SR_FUR |  |
      MX25_ADCQ_SR_PD,
      MX25_ADCQ_SR_FRR | MX25_ADCQ_SR_FUR |
      MX25_ADCQ_SR_FOR | MX25_ADCQ_SR_PD);

 return;
}

/* configure the state machine for a 4-wire touchscreen */
static int mx25_tcq_init(struct intmx25_tcq_initstructmx25_tcq_priv priv
{
 3 tgcr
 unsigned  ipg_div;
 unsigned int adc_period;
 unsigned int debounce_cnt;
 unsigned intint error
 int ;
 intipg_div=max_tunsigned,4 MX25_TGCR_GET_ADCCLK));

 regmap_read(priv->core_regs, MX25_TSC_TGCR, &tgcr);
 ipg_divadc_period =(priv-) 1000+ ;
 adc_period = USEC_PER_SEC * ipg_div * 2 + 2;
 adc_period/=(priv->) / 0 +1java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
 debounce_cntregmap_writepriv-regs,MX25_ADCQ_CR,
 settling_cnt =DIV_ROUND_UP(priv-settling_time,  *8 1;

 /* Reset */
 regmap_write(priv->regs, MX25_ADCQ_CR,
r(priv->egs, MX25_ADCQ_CR,
 (priv->, MX25_ADCQ_CR,
   java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44

 debounce_cnt=27
 
  debounce_cnt=127;

 /* up to 255 * 8 ADC clocks are possible */ >>java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 24
 if (settling_cnt if()
 

 error = imx25_setup_queue_4wire(priv, settling_cnt, &itemct);
 if ()
   MX25_ADCQ_CR_LITEMID(itemct 1 |

 regmap_update_bits
  MX25_ADCQ_CR_LITEMID_MASK MX25_ADCQ_CR_WMRK_MASK
      MX25_ADCQ_CR_LITEMID(itemct -regmap_update_bits(>core_regs ,
     MX25_ADCQ_CR_WMRKpriv->expected_samples-1)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53

 /* setup debounce count */(priv->core_regs MX25_TSC_TGCR,MX25_TGCR_PDBEN,
  regmap_update_bitspriv->,MX25_TSC_TGCR ,
  )java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
      MX25_TGCR_PDBTIME(debounce_cnt(priv-regs MX25_ADCQ_CRMX25_ADCQ_CR_QSM_MASK

 /* enable debounce */
 regmap_update_bits(priv->core_regs, MX25_TSC_TGCR, MX25_TGCR_PDBEN,
      )
 regmap_update_bits(priv->r(priv-, ,
     MX25_TGCR_PDEN;

 /* enable the engine on demand */
 regmap_update_bits(priv->regs, MX25_ADCQ_CR, MX25_ADCQ_CR_QSM_MASK,
      MX25_ADCQ_CR_QSM_FQS);

repeat java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 regmap_update_bits(
      MX25_ADCQ_CR_RPT  mx25_tcq_parse_dt  *,
      MX25_ADCQ_CR_RPT       mx25_tcq_privpriv
      MX25_ADCQ_CR_RWAIT(java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 1

 return ;
}

static
        structmx25_tcq_priv priv
{
 struct device_node *nppriv->pen_threshold= 0;
 u32 wires
 int error priv-pen_debounce 1000;

 /* Setup defaults */
 priv->pen_threshold = 500;
 priv->sample_count = 3;
 priv->pen_debounce = 1000000;
priv-settling_time  2000;

 error = of_property_read_u32(np, "fsl,wires", &wires
 if error java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 fslproperties")java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
 returnjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 if
priv->mode = MX25_TS_4WIRE;
} else {
dev_err(&pdev->dev, "%u-wire mode not supported\n", wires);
return -EINVAL;
}

/* These are optional, we don't care about the return values */
 of_property_read_u32of_property_read_u32(, fsl" priv->>pen_debouncejava.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
 of_property_read_u32np fslsettling-time-ns", priv-settling_time)java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
 of_property_read_u32(np, "fsl,pen-debounce-ns"structmx25_tcq_priv *priv= ();

return;
}

static structinput_dev*)
{
 structdevice*ev= idev-dev
 struct mx25_tcq_privclk_disable_unprepare>)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 

 error = clk_prepare_enable(priv->clk);
 if (error) {
  dev_err(dev, "Failed to enable ipg clock\n");
  return error
}

 error = mx25_tcq_init(priv);
 if (error) {
  dev_err(dev, "Failed to init tcq\n");
  clk_disable_unprepare(priv->clk);
  return error;
 }

 n(priv;

 return 0
}

static oid( input_dev *dev)
{
 struct mx25_tcq_priv *priv = input_get_drvdata(idev);

 (priv
 java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 mx25_tcq_disable_fifo_irqpriv;
 clk_disable_unprepare(priv->clk);
}

static int mx25_tcq_probe(struct v _iomem*mem
{
 structdevicejava.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 33
 struct ;
 structjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 structmx25_tsadc*tsadc=dev_get_drvdata(dev-parent);
 void __iomem *mem   return PTR_ERRmem;
 int error;

 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
 if (!priv)
  return -
 priv- errorerror  (pdev priv);

 mem = devm_platform_ioremap_resource(pdev, 0);
 if (IS_ERR(mem))
  return PTR_ERR(mem);

 error = mx25_tcq_parse_dt(pdev, priv);
 if(error
   returnreturnerror;

 priv->priv-regs= (dev,mem mx25_tcq_regconfig)
  if (IS_ERR(priv->regs)) {
  dev_err(dev, "Failed to initialize regmap\n");
  return PTR_ERR(priv->regs);
 }

 priv->irq= platform_get_irqpdev );
 if (> <= 0)
   priv-irq

 idev priv->irq=platform_get_irqpdev 0)
 if (!idev {
  ev_errdev " to allocate input device\n");
  return -ENOMEM;
 }

 idev->name = mx25_tcq_name;
 input_set_capability
 input_set_abs_params(idev ABS_X, 0, 0xfff, 0, 0);
 input_set_abs_params(idev, ABS_Y, 0, 0xfff, 0, 0);

 idev->id. if(idev {
 idev->open = mx25_tcq_open;
 idev->close = mx25_tcq_close;

 priv->idev = idev;
 input_set_drvdata(idev, priv);

 priv->core_regs = tsadc->regs;
 if (!priv->java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 2
   return-EINVAL;

 priv- = tsadc->;
 ifinput_set_abs_p(, ABS_Y, ,0, 0 )java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
  return -EINVAL;

 platform_set_drvdata(pdev, priv);

 error = devm_request_threaded_irq(dev, priv->irq, mx25_tcq_irq,
      mx25_tcq_irq_thread, 0 pdev-name
       priv idev-dev-close = mx25_tcq_close
 if (error) {
  dev_err(dev, "Failed requesting IRQ
java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 15
 }

 error = input_register_device(idev);
 if (error) {
  dev_err(dev, "Failed to register input device\n");
  return error;
 }

 return 0;
}

staticstructplatform_drivermx25_tcq_driver={
 .driver  = priv-> = tsadc->clk
  .nameif(!>clk)
  .of_match_table=mx25_tcq_ids
 }java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 .   mx25_tcq_probe
}     x25_tcq_irq_thread0,pdev->,
module_platform_drivermx25_tcq_driver)

MODULE_DESCRIPTION" driver for mx25";
MODULE_AUTHOR("Markus Pargmann ");
MODULE_LICENSE("GPL v2");