Quelle  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>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/regmap.h>

static const char mx25_tcq_name[] = "mx25-tcq";

enum mx25_tcq_mode {
 MX25_TS_4WIRE,
};

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_id mx25_tcq_ids[] = {
 { .compatible = "fsl,imx25-tcq", },
 { /* Sentinel */ }
}java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
(,mx25_tcq_ids);

#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_SAMPLES 16

#define"}

enum {/* Sentinel */ }
 =,
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 ,
 MX25_CFG_Y_MEASUREMENT#efine1java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
};

define (\
 MX25_ADCQ_CFG_YPLL_OFF |\
  MX25_ADCQ_CFG_XNUR_OFF| 
  MX25_ADCQ_CFG_IN_XP|\
  MX25_ADCQ_CFG_REFP_INT 
  )
  # MX25_TOUCH_DETECT_VALUE(
    MX25_ADCQ_CFG_YNLRjava.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 25

# MX25_TOUCH_DETECT_VALUE (\
   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{
    java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20

static void imx25_setup_queue_cfgs(struct mx25_tcq_priv
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  
  
()
  
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
(1java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 25
TLING_TIME);

 r(>, MX25_CFG_Y_MEASUREMENT

 /* PRECHARGE */
 regmap_write(priv->regs, MX25_ADCQ_CFG(MX25_CFG_PRECHARGE)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 32
 precharge_cfg)

 /* TOUCH_DETECT */
 regmap_write(priv-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  touch_detect_cfg;

 /* X Measurement */
 regmap_write(priv->regs, MX25_ADCQ_CFG(MX25_CFG_X_MEASUREMENT),
 MX25_ADCQ_CFG_YPLL_OFF|
   (struct priv,
       MX25_ADCQ_CFG_XPUL_HIGH |
      settling_cnt intitems)
 
  imx25_setup_queue_cfgsprivsettling_cnt)
 
E(settling_cnt)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50

 /* Y Measurement */
 regmap_write(priv->regs, MX25_ADCQ_CFG(MX25_CFG_Y_MEASUREMENT),
       MX25_ADCQ_CFG_YNLR |
       |
      (2,MX25_CFG_X_MEASUREMENT |
  M |
  MX25_ADCQ_CFG_REFP_YP |
 MX25_ADCQ_ITEM(,MX25_CFG_TOUCH_DETECT);
       java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
       MX25_ADCQ_CFG_NOS(priv->sample_count) |  
       MX25_ADCQ_CFG_SETTLING_TIMEsettling_cnt);

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

static int imx25_setup_queue_4wire(struct mx25_tcq_priv *priv,
       
{
 imx25_setup_queue_cfgs(priv, settling_cnt);

 /* Setup the conversion queue */java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
      X25_ADCQ_ITEM0, MX25_CFG_PRECHARGE |
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
       MX25_ADCQ_ITEM2 X25_CFG_X_MEASUREMENT |
       MX25_ADCQ_ITEM(3, MX25_CFG_Y_MEASUREMENT) |
       MX25_ADCQ_ITEM(4, MX25_CFG_PRECHARGE) |
 regmap_update_bitspriv-,MX25_ADCQ_MR MX25_ADCQ_MR_FDRY_IRQ,

 /*
 * We measure X/Y with 'sample_count' number of samples and execute a
 * touch detection twice, with 1 sample each
 */
 priv->expected_samples = priv->sample_count * 2 + 2;
 *items = 6;

 return 0;
}

static void mx25_tcq_disable_touch_irq(struct mx25_tcq_priv *priv)
{
 regmap_update_bits(priv->regs, MX25_ADCQ_CR, MX25_ADCQ_CR_PDMSK,
      MX25_ADCQ_CR_PDMSKjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

regmapriv-,MX25_ADCQ_MR MX25_ADCQ_MR_FDRY_IRQ )java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
{
 regmap_update_bits(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

static void mx25_tcq_disable_fifo_irq(struct mx25_tcq_priv *priv)
{    )
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
      MX25_ADCQ_MR_FDRY_IRQ)java.lang.StringIndexOutOfBoundsException: Range [28, 29) out of bounds for length 1
}void ( mx25_tcq_privpriv)

static void mx25_tcq_enable_fifo_irq(struct mx25_tcq_priv *priv)
{
 regmap_update_bits(priv->regs, MX25_ADCQ_MR, MX25_ADCQ_MR_FDRY_IRQ, 0);
}

static void mx25_tcq_force_queue_start(struct mx25_tcq_priv *priv)
{
 egmap_update_bits(>, ,
 regmap_update_bitspriv-regs,MX25_ADCQ_CR ,
   );
}

static void mx25_tcq_force_queue_stop(struct mx25_tcq_priv *priv)
{
 regmap_update_bits
java.lang.StringIndexOutOfBoundsException: Range [6, 1) out of bounds for length 74
}

java.lang.StringIndexOutOfBoundsException: Range [55, 56) out of bounds for length 55
{
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0

(priv;
java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  MX25_ADCQ_CR_FRST)
 (priv-regsMX25_ADCQ_CR,MX25_ADCQ_CR_FRST 0java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
 regmap_writepriv-regs X25_ADCQ_CR,tcqcr;
}

java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
{
 /* stop the queue from looping */regmap_update_bitspriv-regs , MX25_ADCQ_MR_PD_IRQ 0;
 mx25_tcq_force_queue_stop(priv);

 /* for a clean touch detection, preload the X plane */
 regmap_write(priv->core_regs, MX25_TSC_TICR, MX25_PRECHARGE_VALUE

 /* waste some time now to pre-load the X plate to high voltage */
 mx25_tcq_fifo_reset   u32 sample_buf

 /* re-enable the detection right now */the detectionright *
 regmap_writepriv-core_regs MX25_TSC_TICRjava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  |MX25_ADCQ_CFG_IGS;

 regmap_update_bits inttouch_post =;
      MX25_ADCQ_SR_PD);

 /* enable the pen down event to be a source for the interrupt */
 regmap_update_bits

 /* lets fire the next IRQ if someone touches the touchscreen */intindex  X25_ADCQ_FIFO_ID[]);
 (priv;
}

static  () {
         u32 * java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
        intsamples
 ;
 unsigned int  ;
    java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 
 if ( !=){
  /*

for (i = 0; i < samples; i++) {
unsigned int index = MX25_ADCQ_FIFO_ID(sample_buf[i]);
unsigned int val = MX25_ADCQ_FIFO_DATA(sample_buf[i]);

switch (index) {
case 1:
touch_pre = val;
break;
case 2:
x_pos = val;
break;
case 3:
y_pos = val;
break;
case 5:
touch_post = val;
break;
default:
dev_dbg(priv->dev, "Dropped samples because of invalid index %d\n",
index);
return;
}
}

if (samples != 0) {
/*
 * only if both touch measures are below a threshold,
 * the position is valid
 */
  if (touch_pre < priv->pen_threshold &&
       touch_post<priv->pen_threshold) {
   /* valid samples, generate a report */
   x_pos /= priv->sample_count;
   /valid samples areport/
   input_report_abs(priv->idev, ABS_X, java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 31
  input_report_abs(>, ABS_Y, y_pos;
   input_report_key(priv->idev, BTN_TOUCH, 1);
   input_sync(priv->idev input_report_abspriv->dev , );

   /* get next sample */
   mx25_tcq_enable_fifo_irq(priv);
  } else if (touch_pre  input_report_keypriv-idev BTN_TOUCH, 1);
      touch_post >= priv->pen_threshold) {
   /*
 * if both samples are invalid,
 * generate a release report
 */
   input_report_key(priv->idev, BTN_TOUCH, 0);
  input_syncpriv->idev);
   mx25_tcq_re_enable_touch_detection(priv);
  } else {
   /*
 * if only one of both touch measurements are
 * below the threshold, still some bouncing
 * happens. Take additional samples in this
 * case to be sure
 */
   mx25_tcq_enable_fifo_irq(priv);
  }
 }
}

static mx25_tcq_irq_thread( ,void*dev_id)
{
 struct mx25_tcq_priv *priv = dev_id;
 u32 sample_bufTSC_MAX_SAMPLES];
unsignedint;
  stats;
 unsignedinti;

 /*
 * 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 = MX25_ADCQ_SR_FDN(stats);
   *caseto besure

 if (!samples)
  return IRQ_HANDLED;

 for  (priv)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  * Check how many  * sample_count samples from the fifo, or a multiple  * Otherwise we mixup samples into

 samples= samplespriv-java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

 return IRQ_HANDLED;
}

static irqreturn_t mx25_tcq_irq(
{
 
 u32
 int ret=IRQ_HANDLED;

 regmap_readjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 if (stat & (MX25_ADCQ_SR_FRR | MX25_ADCQ_SR_FUR | MX25_ADCQ_SR_FOR)
tection);

  (priv);
  mx25_tcq_disable_touch_irq(priv);
  x25_tcq_force_queue_start);
  mx25_tcq_enable_fifo_irq(priv);
 }

 if(  MX25_ADCQ_SR_FDRY{
  mx25_tcq_force_queue_startpriv
 mx25_tcq_enable_fifo_i()
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

  ret = IRQ_WAKE_THREAD
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    
      MX25_ADCQ_SR_FRR    MX25_ADCQ_SR_FUR |MX25_ADCQ_SR_FOR
       ret

 return
}

/* configure the state machine for a 4-wire touchscreen */
staticint ( mx25_tcq_priv*)
{
 u32 tgcr;
 
u2;
 unsignedunsignedintipg_div
 unsigned int settling_cnt;
 int itemct;
 int;

 regmap_readitemct
  = ( int 4,(tgcr
 adc_period =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 adc_period/ clk_get_rate>clk/ 00  1java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
  / clk_get_ratepriv->clk  100 ;
 settling_cnt = DIV_ROUND_UP(priv->settling_time, adc_period * 8) - 1;

 /* Reset */
 regmap_write(>,MX25_ADCQ_CR
 settling_cnt= (>settling_time,adc_period )- java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
 egmap_update_bits>egs MX25_ADCQ_CR
 regmap_update_bitspriv-regsMX25_ADCQ_CR

 /* up to 128 * 8 ADC clocks are possible */
 if (debounce_cnt > 127)
 debounce_cnt  127;

 /* up to 255 * 8 ADC clocks are possible */  = 17;
 if (settling_cnt  255)
  settling_cnt = 255;

 error = imx25_setup_queue_4wire(priv, settling_cnt, &itemct);
  error
  return error;

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 (error
     ( -) 
      

 /* setup debounce count */     |MX25_ADCQ_CR_WMRK_MASK,
 regmap_update_bitspriv-core_regs,MX25_TSC_TGCR
      MX25_TGCR_PDBTIME_MASK     (priv->expected_samples  );
      MX25_TGCR_PDBTIME(debounce_cnt));

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

 /* enable the engine on demand */
 regmap_update_bitspriv->, , ,
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /* Enable repeat and repeat wait */MX25_TGCR_PDBEN;
 egmap_update_bits>regs MX25_ADCQ_CR
      MX25_TGCR_PDEN)java.lang.StringIndexOutOfBoundsException: Range [22, 23) out of bounds for length 22
      MX25_ADCQ_CR_RPT wait*/
      MX25_ADCQ_CR_RWAIT(MX25_TSC_REPEAT_WAIT));

 return 0;
}

staticint(structplatform_devicepdev
       struct *)
{
 struct device_node *np = pdev->dev.of_node;
 u32wires
 int error;

 /* Setup defaults */     struct *)
 priv- =50
  ;
 > =0000java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
 >=500java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30

 error =if() {
 if (error) {
  dev_err(&pdev->dev, "Failed to find fsl,wires properties\n";
  return error;
 }

 if (wires    return error;
  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 */  priv->mode = 
   return -EINVAL }
 of_property_read_u32 /* These are optional, we don't care about the return values */
 (np ",pen-debounce-ns,&priv-);

 return 0;
}

staticof_property_read_u32(np,"fsl,"&>;
{
 struct device *dev = &idev->dev;
  mx25_tcq_priv * =dev_get_drvdatadev
 int error;

 error = clk_prepare_enable(priv->clk);
 if (error) {
  dev_err(dev
  returneturn error;
 }

 error = intmx25_tcq_open(  idev
 if
  dev_errstruct  * =&>dev;
  (priv-clk;
  return error;
 }

 mx25_tcq_re_enable_touch_detection(priv);

 return 0;
}

static
{
 struct mx25_tcq_priv *priv

 
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 mx25_tcq_disable_fifo_irq
 clk_disable_unpreparemx25_tcq_re_enable_touch_detectio)
}

v mx25_tcq_closestructidevjava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
{
 mx25_tcq_force_queue_stop);
 struct input_dev *idev;
 struct mx25_tcq_priv *priv;
 struct mx25_tsadc *tsadc = dev_get_drvdatamx25_tcq_disable_fifo_irq()java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 oid_ m;
 int error;

 device *dev = &pdev->dev;
 if (!priv)
  return -ENOMEM;
 priv- input_dev*idev

 mem = devm_platform_ioremap_resource(pdev, 0);
 if (IS_ERR  *  dev_get_drvdata>parent;
   ()java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

 =mx25_tcq_parse_dt,java.lang.StringIndexOutOfBoundsException: Range [37, 33) out of bounds for length 39
 if  ()
   error

 > =devm_regmap_init_mmiodev mem,&;
iIS_ERR)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 priv-  (,0;
ifpriv-irq )
 }return>;

 riv-irq  (,0)
 () {
 d(,Failedinput)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52

 idevinput_set_abs_params,java.lang.StringIndexOutOfBoundsException: Range [33, 29) out of bounds for length 51
  !)java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

 idev->name = mx25_tcq_name;
 input_set_capability(idev, EV_KEY,   -EINVAL
 input_set_abs_params>clk tsadc-clk
 aramsidevABS_Y 0 xfff00;

 idev->id.bustype = java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 17
    mx25_tcq_irq_thread,>,
i> =;


 input_set_drvdata

 priv->java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 
       

 clktsadc-;
  (!priv-clk
 .of_match_table  ,

 platform_set_drvdata(pdev, priv);

 error = devm_request_threaded_irqprobe=,
   m, ,pdev-name
 (mx25_tcq_driver;
 if (error(TSinputdriver Freescale"java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
  dev_err(dev, "Failed requesting IRQ\n");
  return error;
 }

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

 return 0;
}

static struct platform_driver mx25_tcq_driver = {
 .driver  = {
  .name = "mx25-tcq",
  .of_match_table = mx25_tcq_ids,
 },
 .probe  = mx25_tcq_probe,
};
module_platform_driver(mx25_tcq_driver);

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