Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Freescale MXS LRADC touchscreen driver
0004  *
0005  * Copyright (c) 2012 DENX Software Engineering, GmbH.
0006  * Copyright (c) 2017 Ksenija Stanojevic <ksenija.stanojevic@gmail.com>
0007  *
0008  * Authors:
0009  *  Marek Vasut <marex@denx.de>
0010  *  Ksenija Stanojevic <ksenija.stanojevic@gmail.com>
0011  */
0012 
0013 #include <linux/device.h>
0014 #include <linux/err.h>
0015 #include <linux/input.h>
0016 #include <linux/interrupt.h>
0017 #include <linux/module.h>
0018 #include <linux/mfd/core.h>
0019 #include <linux/mfd/mxs-lradc.h>
0020 #include <linux/of.h>
0021 #include <linux/of_irq.h>
0022 #include <linux/platform_device.h>
0023 
0024 static const char * const mxs_lradc_ts_irq_names[] = {
0025     "mxs-lradc-touchscreen",
0026     "mxs-lradc-channel6",
0027     "mxs-lradc-channel7",
0028 };
0029 
0030 /*
0031  * Touchscreen handling
0032  */
0033 enum mxs_lradc_ts_plate {
0034     LRADC_TOUCH = 0,
0035     LRADC_SAMPLE_X,
0036     LRADC_SAMPLE_Y,
0037     LRADC_SAMPLE_PRESSURE,
0038     LRADC_SAMPLE_VALID,
0039 };
0040 
0041 struct mxs_lradc_ts {
0042     struct mxs_lradc    *lradc;
0043     struct device       *dev;
0044 
0045     void __iomem        *base;
0046     /*
0047      * When the touchscreen is enabled, we give it two private virtual
0048      * channels: #6 and #7. This means that only 6 virtual channels (instead
0049      * of 8) will be available for buffered capture.
0050      */
0051 #define TOUCHSCREEN_VCHANNEL1       7
0052 #define TOUCHSCREEN_VCHANNEL2       6
0053 
0054     struct input_dev    *ts_input;
0055 
0056     enum mxs_lradc_ts_plate cur_plate; /* state machine */
0057     bool            ts_valid;
0058     unsigned int        ts_x_pos;
0059     unsigned int        ts_y_pos;
0060     unsigned int        ts_pressure;
0061 
0062     /* handle touchscreen's physical behaviour */
0063     /* samples per coordinate */
0064     unsigned int        over_sample_cnt;
0065     /* time clocks between samples */
0066     unsigned int        over_sample_delay;
0067     /* time in clocks to wait after the plates where switched */
0068     unsigned int        settling_delay;
0069     spinlock_t      lock;
0070 };
0071 
0072 struct state_info {
0073     u32     mask;
0074     u32     bit;
0075     u32     x_plate;
0076     u32     y_plate;
0077     u32     pressure;
0078 };
0079 
0080 static struct state_info info[] = {
0081     {LRADC_CTRL0_MX23_PLATE_MASK, LRADC_CTRL0_MX23_TOUCH_DETECT_ENABLE,
0082      LRADC_CTRL0_MX23_XP | LRADC_CTRL0_MX23_XM,
0083      LRADC_CTRL0_MX23_YP | LRADC_CTRL0_MX23_YM,
0084      LRADC_CTRL0_MX23_YP | LRADC_CTRL0_MX23_XM},
0085     {LRADC_CTRL0_MX28_PLATE_MASK, LRADC_CTRL0_MX28_TOUCH_DETECT_ENABLE,
0086      LRADC_CTRL0_MX28_XPPSW | LRADC_CTRL0_MX28_XNNSW,
0087      LRADC_CTRL0_MX28_YPPSW | LRADC_CTRL0_MX28_YNNSW,
0088      LRADC_CTRL0_MX28_YPPSW | LRADC_CTRL0_MX28_XNNSW}
0089 };
0090 
0091 static bool mxs_lradc_check_touch_event(struct mxs_lradc_ts *ts)
0092 {
0093     return !!(readl(ts->base + LRADC_STATUS) &
0094                     LRADC_STATUS_TOUCH_DETECT_RAW);
0095 }
0096 
0097 static void mxs_lradc_map_ts_channel(struct mxs_lradc_ts *ts, unsigned int vch,
0098                      unsigned int ch)
0099 {
0100     writel(LRADC_CTRL4_LRADCSELECT_MASK(vch),
0101            ts->base + LRADC_CTRL4 + STMP_OFFSET_REG_CLR);
0102     writel(LRADC_CTRL4_LRADCSELECT(vch, ch),
0103            ts->base + LRADC_CTRL4 + STMP_OFFSET_REG_SET);
0104 }
0105 
0106 static void mxs_lradc_setup_ts_channel(struct mxs_lradc_ts *ts, unsigned int ch)
0107 {
0108     /*
0109      * prepare for oversampling conversion
0110      *
0111      * from the datasheet:
0112      * "The ACCUMULATE bit in the appropriate channel register
0113      * HW_LRADC_CHn must be set to 1 if NUM_SAMPLES is greater then 0;
0114      * otherwise, the IRQs will not fire."
0115      */
0116     writel(LRADC_CH_ACCUMULATE |
0117            LRADC_CH_NUM_SAMPLES(ts->over_sample_cnt - 1),
0118            ts->base + LRADC_CH(ch));
0119 
0120     /* from the datasheet:
0121      * "Software must clear this register in preparation for a
0122      * multi-cycle accumulation.
0123      */
0124     writel(LRADC_CH_VALUE_MASK,
0125            ts->base + LRADC_CH(ch) + STMP_OFFSET_REG_CLR);
0126 
0127     /*
0128      * prepare the delay/loop unit according to the oversampling count
0129      *
0130      * from the datasheet:
0131      * "The DELAY fields in HW_LRADC_DELAY0, HW_LRADC_DELAY1,
0132      * HW_LRADC_DELAY2, and HW_LRADC_DELAY3 must be non-zero; otherwise,
0133      * the LRADC will not trigger the delay group."
0134      */
0135     writel(LRADC_DELAY_TRIGGER(1 << ch) | LRADC_DELAY_TRIGGER_DELAYS(0) |
0136            LRADC_DELAY_LOOP(ts->over_sample_cnt - 1) |
0137            LRADC_DELAY_DELAY(ts->over_sample_delay - 1),
0138            ts->base + LRADC_DELAY(3));
0139 
0140     writel(LRADC_CTRL1_LRADC_IRQ(ch),
0141            ts->base + LRADC_CTRL1 + STMP_OFFSET_REG_CLR);
0142 
0143     /*
0144      * after changing the touchscreen plates setting
0145      * the signals need some initial time to settle. Start the
0146      * SoC's delay unit and start the conversion later
0147      * and automatically.
0148      */
0149     writel(LRADC_DELAY_TRIGGER(0) | LRADC_DELAY_TRIGGER_DELAYS(BIT(3)) |
0150            LRADC_DELAY_KICK | LRADC_DELAY_DELAY(ts->settling_delay),
0151            ts->base + LRADC_DELAY(2));
0152 }
0153 
0154 /*
0155  * Pressure detection is special:
0156  * We want to do both required measurements for the pressure detection in
0157  * one turn. Use the hardware features to chain both conversions and let the
0158  * hardware report one interrupt if both conversions are done
0159  */
0160 static void mxs_lradc_setup_ts_pressure(struct mxs_lradc_ts *ts,
0161                     unsigned int ch1, unsigned int ch2)
0162 {
0163     u32 reg;
0164 
0165     /*
0166      * prepare for oversampling conversion
0167      *
0168      * from the datasheet:
0169      * "The ACCUMULATE bit in the appropriate channel register
0170      * HW_LRADC_CHn must be set to 1 if NUM_SAMPLES is greater then 0;
0171      * otherwise, the IRQs will not fire."
0172      */
0173     reg = LRADC_CH_ACCUMULATE |
0174         LRADC_CH_NUM_SAMPLES(ts->over_sample_cnt - 1);
0175     writel(reg, ts->base + LRADC_CH(ch1));
0176     writel(reg, ts->base + LRADC_CH(ch2));
0177 
0178     /* from the datasheet:
0179      * "Software must clear this register in preparation for a
0180      * multi-cycle accumulation.
0181      */
0182     writel(LRADC_CH_VALUE_MASK,
0183            ts->base + LRADC_CH(ch1) + STMP_OFFSET_REG_CLR);
0184     writel(LRADC_CH_VALUE_MASK,
0185            ts->base + LRADC_CH(ch2) + STMP_OFFSET_REG_CLR);
0186 
0187     /* prepare the delay/loop unit according to the oversampling count */
0188     writel(LRADC_DELAY_TRIGGER(1 << ch1) | LRADC_DELAY_TRIGGER(1 << ch2) |
0189            LRADC_DELAY_TRIGGER_DELAYS(0) |
0190            LRADC_DELAY_LOOP(ts->over_sample_cnt - 1) |
0191            LRADC_DELAY_DELAY(ts->over_sample_delay - 1),
0192            ts->base + LRADC_DELAY(3));
0193 
0194     writel(LRADC_CTRL1_LRADC_IRQ(ch2),
0195            ts->base + LRADC_CTRL1 + STMP_OFFSET_REG_CLR);
0196 
0197     /*
0198      * after changing the touchscreen plates setting
0199      * the signals need some initial time to settle. Start the
0200      * SoC's delay unit and start the conversion later
0201      * and automatically.
0202      */
0203     writel(LRADC_DELAY_TRIGGER(0) | LRADC_DELAY_TRIGGER_DELAYS(BIT(3)) |
0204            LRADC_DELAY_KICK | LRADC_DELAY_DELAY(ts->settling_delay),
0205            ts->base + LRADC_DELAY(2));
0206 }
0207 
0208 static unsigned int mxs_lradc_ts_read_raw_channel(struct mxs_lradc_ts *ts,
0209                           unsigned int channel)
0210 {
0211     u32 reg;
0212     unsigned int num_samples, val;
0213 
0214     reg = readl(ts->base + LRADC_CH(channel));
0215     if (reg & LRADC_CH_ACCUMULATE)
0216         num_samples = ts->over_sample_cnt;
0217     else
0218         num_samples = 1;
0219 
0220     val = (reg & LRADC_CH_VALUE_MASK) >> LRADC_CH_VALUE_OFFSET;
0221     return val / num_samples;
0222 }
0223 
0224 static unsigned int mxs_lradc_read_ts_pressure(struct mxs_lradc_ts *ts,
0225                     unsigned int ch1, unsigned int ch2)
0226 {
0227     u32 reg, mask;
0228     unsigned int pressure, m1, m2;
0229 
0230     mask = LRADC_CTRL1_LRADC_IRQ(ch1) | LRADC_CTRL1_LRADC_IRQ(ch2);
0231     reg = readl(ts->base + LRADC_CTRL1) & mask;
0232 
0233     while (reg != mask) {
0234         reg = readl(ts->base + LRADC_CTRL1) & mask;
0235         dev_dbg(ts->dev, "One channel is still busy: %X\n", reg);
0236     }
0237 
0238     m1 = mxs_lradc_ts_read_raw_channel(ts, ch1);
0239     m2 = mxs_lradc_ts_read_raw_channel(ts, ch2);
0240 
0241     if (m2 == 0) {
0242         dev_warn(ts->dev, "Cannot calculate pressure\n");
0243         return 1 << (LRADC_RESOLUTION - 1);
0244     }
0245 
0246     /* simply scale the value from 0 ... max ADC resolution */
0247     pressure = m1;
0248     pressure *= (1 << LRADC_RESOLUTION);
0249     pressure /= m2;
0250 
0251     dev_dbg(ts->dev, "Pressure = %u\n", pressure);
0252     return pressure;
0253 }
0254 
0255 #define TS_CH_XP 2
0256 #define TS_CH_YP 3
0257 #define TS_CH_XM 4
0258 #define TS_CH_YM 5
0259 
0260 /*
0261  * YP(open)--+-------------+
0262  *       |         |--+
0263  *       |         |  |
0264  *    YM(-)--+-------------+  |
0265  *         +--------------+
0266  *         |          |
0267  *     XP(weak+)        XM(open)
0268  *
0269  * "weak+" means 200k Ohm VDDIO
0270  * (-) means GND
0271  */
0272 static void mxs_lradc_setup_touch_detection(struct mxs_lradc_ts *ts)
0273 {
0274     struct mxs_lradc *lradc = ts->lradc;
0275 
0276     /*
0277      * In order to detect a touch event the 'touch detect enable' bit
0278      * enables:
0279      *  - a weak pullup to the X+ connector
0280      *  - a strong ground at the Y- connector
0281      */
0282     writel(info[lradc->soc].mask,
0283            ts->base + LRADC_CTRL0 + STMP_OFFSET_REG_CLR);
0284     writel(info[lradc->soc].bit,
0285            ts->base + LRADC_CTRL0 + STMP_OFFSET_REG_SET);
0286 }
0287 
0288 /*
0289  * YP(meas)--+-------------+
0290  *       |         |--+
0291  *       |         |  |
0292  * YM(open)--+-------------+  |
0293  *         +--------------+
0294  *         |          |
0295  *       XP(+)      XM(-)
0296  *
0297  * (+) means here 1.85 V
0298  * (-) means here GND
0299  */
0300 static void mxs_lradc_prepare_x_pos(struct mxs_lradc_ts *ts)
0301 {
0302     struct mxs_lradc *lradc = ts->lradc;
0303 
0304     writel(info[lradc->soc].mask,
0305            ts->base + LRADC_CTRL0 + STMP_OFFSET_REG_CLR);
0306     writel(info[lradc->soc].x_plate,
0307            ts->base + LRADC_CTRL0 + STMP_OFFSET_REG_SET);
0308 
0309     ts->cur_plate = LRADC_SAMPLE_X;
0310     mxs_lradc_map_ts_channel(ts, TOUCHSCREEN_VCHANNEL1, TS_CH_YP);
0311     mxs_lradc_setup_ts_channel(ts, TOUCHSCREEN_VCHANNEL1);
0312 }
0313 
0314 /*
0315  *   YP(+)--+-------------+
0316  *      |         |--+
0317  *      |         |  |
0318  *   YM(-)--+-------------+  |
0319  *        +--------------+
0320  *        |          |
0321  *     XP(open)    XM(meas)
0322  *
0323  * (+) means here 1.85 V
0324  * (-) means here GND
0325  */
0326 static void mxs_lradc_prepare_y_pos(struct mxs_lradc_ts *ts)
0327 {
0328     struct mxs_lradc *lradc = ts->lradc;
0329 
0330     writel(info[lradc->soc].mask,
0331            ts->base + LRADC_CTRL0 + STMP_OFFSET_REG_CLR);
0332     writel(info[lradc->soc].y_plate,
0333            ts->base + LRADC_CTRL0 + STMP_OFFSET_REG_SET);
0334 
0335     ts->cur_plate = LRADC_SAMPLE_Y;
0336     mxs_lradc_map_ts_channel(ts, TOUCHSCREEN_VCHANNEL1, TS_CH_XM);
0337     mxs_lradc_setup_ts_channel(ts, TOUCHSCREEN_VCHANNEL1);
0338 }
0339 
0340 /*
0341  *    YP(+)--+-------------+
0342  *       |         |--+
0343  *       |         |  |
0344  * YM(meas)--+-------------+  |
0345  *         +--------------+
0346  *         |          |
0347  *      XP(meas)        XM(-)
0348  *
0349  * (+) means here 1.85 V
0350  * (-) means here GND
0351  */
0352 static void mxs_lradc_prepare_pressure(struct mxs_lradc_ts *ts)
0353 {
0354     struct mxs_lradc *lradc = ts->lradc;
0355 
0356     writel(info[lradc->soc].mask,
0357            ts->base + LRADC_CTRL0 + STMP_OFFSET_REG_CLR);
0358     writel(info[lradc->soc].pressure,
0359            ts->base + LRADC_CTRL0 + STMP_OFFSET_REG_SET);
0360 
0361     ts->cur_plate = LRADC_SAMPLE_PRESSURE;
0362     mxs_lradc_map_ts_channel(ts, TOUCHSCREEN_VCHANNEL1, TS_CH_YM);
0363     mxs_lradc_map_ts_channel(ts, TOUCHSCREEN_VCHANNEL2, TS_CH_XP);
0364     mxs_lradc_setup_ts_pressure(ts, TOUCHSCREEN_VCHANNEL2,
0365                     TOUCHSCREEN_VCHANNEL1);
0366 }
0367 
0368 static void mxs_lradc_enable_touch_detection(struct mxs_lradc_ts *ts)
0369 {
0370     mxs_lradc_setup_touch_detection(ts);
0371 
0372     ts->cur_plate = LRADC_TOUCH;
0373     writel(LRADC_CTRL1_TOUCH_DETECT_IRQ | LRADC_CTRL1_TOUCH_DETECT_IRQ_EN,
0374            ts->base + LRADC_CTRL1 + STMP_OFFSET_REG_CLR);
0375     writel(LRADC_CTRL1_TOUCH_DETECT_IRQ_EN,
0376            ts->base + LRADC_CTRL1 + STMP_OFFSET_REG_SET);
0377 }
0378 
0379 static void mxs_lradc_start_touch_event(struct mxs_lradc_ts *ts)
0380 {
0381     writel(LRADC_CTRL1_TOUCH_DETECT_IRQ_EN,
0382            ts->base + LRADC_CTRL1 + STMP_OFFSET_REG_CLR);
0383     writel(LRADC_CTRL1_LRADC_IRQ_EN(TOUCHSCREEN_VCHANNEL1),
0384            ts->base + LRADC_CTRL1 + STMP_OFFSET_REG_SET);
0385     /*
0386      * start with the Y-pos, because it uses nearly the same plate
0387      * settings like the touch detection
0388      */
0389     mxs_lradc_prepare_y_pos(ts);
0390 }
0391 
0392 static void mxs_lradc_report_ts_event(struct mxs_lradc_ts *ts)
0393 {
0394     input_report_abs(ts->ts_input, ABS_X, ts->ts_x_pos);
0395     input_report_abs(ts->ts_input, ABS_Y, ts->ts_y_pos);
0396     input_report_abs(ts->ts_input, ABS_PRESSURE, ts->ts_pressure);
0397     input_report_key(ts->ts_input, BTN_TOUCH, 1);
0398     input_sync(ts->ts_input);
0399 }
0400 
0401 static void mxs_lradc_complete_touch_event(struct mxs_lradc_ts *ts)
0402 {
0403     mxs_lradc_setup_touch_detection(ts);
0404     ts->cur_plate = LRADC_SAMPLE_VALID;
0405     /*
0406      * start a dummy conversion to burn time to settle the signals
0407      * note: we are not interested in the conversion's value
0408      */
0409     writel(0, ts->base + LRADC_CH(TOUCHSCREEN_VCHANNEL1));
0410     writel(LRADC_CTRL1_LRADC_IRQ(TOUCHSCREEN_VCHANNEL1) |
0411            LRADC_CTRL1_LRADC_IRQ(TOUCHSCREEN_VCHANNEL2),
0412            ts->base + LRADC_CTRL1 + STMP_OFFSET_REG_CLR);
0413     writel(LRADC_DELAY_TRIGGER(1 << TOUCHSCREEN_VCHANNEL1) |
0414            LRADC_DELAY_KICK | LRADC_DELAY_DELAY(10),
0415            ts->base + LRADC_DELAY(2));
0416 }
0417 
0418 /*
0419  * in order to avoid false measurements, report only samples where
0420  * the surface is still touched after the position measurement
0421  */
0422 static void mxs_lradc_finish_touch_event(struct mxs_lradc_ts *ts, bool valid)
0423 {
0424     /* if it is still touched, report the sample */
0425     if (valid && mxs_lradc_check_touch_event(ts)) {
0426         ts->ts_valid = true;
0427         mxs_lradc_report_ts_event(ts);
0428     }
0429 
0430     /* if it is even still touched, continue with the next measurement */
0431     if (mxs_lradc_check_touch_event(ts)) {
0432         mxs_lradc_prepare_y_pos(ts);
0433         return;
0434     }
0435 
0436     if (ts->ts_valid) {
0437         /* signal the release */
0438         ts->ts_valid = false;
0439         input_report_key(ts->ts_input, BTN_TOUCH, 0);
0440         input_sync(ts->ts_input);
0441     }
0442 
0443     /* if it is released, wait for the next touch via IRQ */
0444     ts->cur_plate = LRADC_TOUCH;
0445     writel(0, ts->base + LRADC_DELAY(2));
0446     writel(0, ts->base + LRADC_DELAY(3));
0447     writel(LRADC_CTRL1_TOUCH_DETECT_IRQ |
0448            LRADC_CTRL1_LRADC_IRQ_EN(TOUCHSCREEN_VCHANNEL1) |
0449            LRADC_CTRL1_LRADC_IRQ(TOUCHSCREEN_VCHANNEL1),
0450            ts->base + LRADC_CTRL1 + STMP_OFFSET_REG_CLR);
0451     writel(LRADC_CTRL1_TOUCH_DETECT_IRQ_EN,
0452            ts->base + LRADC_CTRL1 + STMP_OFFSET_REG_SET);
0453 }
0454 
0455 /* touchscreen's state machine */
0456 static void mxs_lradc_handle_touch(struct mxs_lradc_ts *ts)
0457 {
0458     switch (ts->cur_plate) {
0459     case LRADC_TOUCH:
0460         if (mxs_lradc_check_touch_event(ts))
0461             mxs_lradc_start_touch_event(ts);
0462         writel(LRADC_CTRL1_TOUCH_DETECT_IRQ,
0463                ts->base + LRADC_CTRL1 + STMP_OFFSET_REG_CLR);
0464         return;
0465 
0466     case LRADC_SAMPLE_Y:
0467         ts->ts_y_pos =
0468             mxs_lradc_ts_read_raw_channel(ts, TOUCHSCREEN_VCHANNEL1);
0469         mxs_lradc_prepare_x_pos(ts);
0470         return;
0471 
0472     case LRADC_SAMPLE_X:
0473         ts->ts_x_pos =
0474             mxs_lradc_ts_read_raw_channel(ts, TOUCHSCREEN_VCHANNEL1);
0475         mxs_lradc_prepare_pressure(ts);
0476         return;
0477 
0478     case LRADC_SAMPLE_PRESSURE:
0479         ts->ts_pressure =
0480             mxs_lradc_read_ts_pressure(ts,
0481                            TOUCHSCREEN_VCHANNEL2,
0482                            TOUCHSCREEN_VCHANNEL1);
0483         mxs_lradc_complete_touch_event(ts);
0484         return;
0485 
0486     case LRADC_SAMPLE_VALID:
0487         mxs_lradc_finish_touch_event(ts, 1);
0488         break;
0489     }
0490 }
0491 
0492 /* IRQ Handling */
0493 static irqreturn_t mxs_lradc_ts_handle_irq(int irq, void *data)
0494 {
0495     struct mxs_lradc_ts *ts = data;
0496     struct mxs_lradc *lradc = ts->lradc;
0497     unsigned long reg = readl(ts->base + LRADC_CTRL1);
0498     u32 clr_irq = mxs_lradc_irq_mask(lradc);
0499     const u32 ts_irq_mask =
0500         LRADC_CTRL1_TOUCH_DETECT_IRQ |
0501         LRADC_CTRL1_LRADC_IRQ(TOUCHSCREEN_VCHANNEL1) |
0502         LRADC_CTRL1_LRADC_IRQ(TOUCHSCREEN_VCHANNEL2);
0503     unsigned long flags;
0504 
0505     if (!(reg & mxs_lradc_irq_mask(lradc)))
0506         return IRQ_NONE;
0507 
0508     if (reg & ts_irq_mask) {
0509         spin_lock_irqsave(&ts->lock, flags);
0510         mxs_lradc_handle_touch(ts);
0511         spin_unlock_irqrestore(&ts->lock, flags);
0512         /* Make sure we don't clear the next conversion's interrupt. */
0513         clr_irq &= ~(LRADC_CTRL1_LRADC_IRQ(TOUCHSCREEN_VCHANNEL1) |
0514                 LRADC_CTRL1_LRADC_IRQ(TOUCHSCREEN_VCHANNEL2));
0515         writel(reg & clr_irq,
0516                ts->base + LRADC_CTRL1 + STMP_OFFSET_REG_CLR);
0517     }
0518 
0519     return IRQ_HANDLED;
0520 }
0521 
0522 static int mxs_lradc_ts_open(struct input_dev *dev)
0523 {
0524     struct mxs_lradc_ts *ts = input_get_drvdata(dev);
0525 
0526     /* Enable the touch-detect circuitry. */
0527     mxs_lradc_enable_touch_detection(ts);
0528 
0529     return 0;
0530 }
0531 
0532 static void mxs_lradc_ts_stop(struct mxs_lradc_ts *ts)
0533 {
0534     int i;
0535     struct mxs_lradc *lradc = ts->lradc;
0536 
0537     /* stop all interrupts from firing */
0538     writel(LRADC_CTRL1_TOUCH_DETECT_IRQ_EN |
0539            LRADC_CTRL1_LRADC_IRQ_EN(TOUCHSCREEN_VCHANNEL1) |
0540            LRADC_CTRL1_LRADC_IRQ_EN(TOUCHSCREEN_VCHANNEL2),
0541            ts->base + LRADC_CTRL1 + STMP_OFFSET_REG_CLR);
0542 
0543     /* Power-down touchscreen touch-detect circuitry. */
0544     writel(info[lradc->soc].mask,
0545            ts->base + LRADC_CTRL0 + STMP_OFFSET_REG_CLR);
0546 
0547     writel(lradc->buffer_vchans << LRADC_CTRL1_LRADC_IRQ_EN_OFFSET,
0548            ts->base + LRADC_CTRL1 + STMP_OFFSET_REG_CLR);
0549 
0550     for (i = 1; i < LRADC_MAX_DELAY_CHANS; i++)
0551         writel(0, ts->base + LRADC_DELAY(i));
0552 }
0553 
0554 static void mxs_lradc_ts_close(struct input_dev *dev)
0555 {
0556     struct mxs_lradc_ts *ts = input_get_drvdata(dev);
0557 
0558     mxs_lradc_ts_stop(ts);
0559 }
0560 
0561 static void mxs_lradc_ts_hw_init(struct mxs_lradc_ts *ts)
0562 {
0563     struct mxs_lradc *lradc = ts->lradc;
0564 
0565     /* Configure the touchscreen type */
0566     if (lradc->soc == IMX28_LRADC) {
0567         writel(LRADC_CTRL0_MX28_TOUCH_SCREEN_TYPE,
0568                ts->base + LRADC_CTRL0 + STMP_OFFSET_REG_CLR);
0569 
0570         if (lradc->touchscreen_wire == MXS_LRADC_TOUCHSCREEN_5WIRE)
0571             writel(LRADC_CTRL0_MX28_TOUCH_SCREEN_TYPE,
0572                    ts->base + LRADC_CTRL0 + STMP_OFFSET_REG_SET);
0573     }
0574 }
0575 
0576 static int mxs_lradc_ts_register(struct mxs_lradc_ts *ts)
0577 {
0578     struct input_dev *input;
0579     struct device *dev = ts->dev;
0580 
0581     input = devm_input_allocate_device(dev);
0582     if (!input)
0583         return -ENOMEM;
0584 
0585     input->name = "mxs-lradc-ts";
0586     input->id.bustype = BUS_HOST;
0587     input->open = mxs_lradc_ts_open;
0588     input->close = mxs_lradc_ts_close;
0589 
0590     __set_bit(INPUT_PROP_DIRECT, input->propbit);
0591     input_set_capability(input, EV_KEY, BTN_TOUCH);
0592     input_set_abs_params(input, ABS_X, 0, LRADC_SINGLE_SAMPLE_MASK, 0, 0);
0593     input_set_abs_params(input, ABS_Y, 0, LRADC_SINGLE_SAMPLE_MASK, 0, 0);
0594     input_set_abs_params(input, ABS_PRESSURE, 0, LRADC_SINGLE_SAMPLE_MASK,
0595                  0, 0);
0596 
0597     ts->ts_input = input;
0598     input_set_drvdata(input, ts);
0599 
0600     return input_register_device(input);
0601 }
0602 
0603 static int mxs_lradc_ts_probe(struct platform_device *pdev)
0604 {
0605     struct device *dev = &pdev->dev;
0606     struct device_node *node = dev->parent->of_node;
0607     struct mxs_lradc *lradc = dev_get_drvdata(dev->parent);
0608     struct mxs_lradc_ts *ts;
0609     int ret, irq, virq, i;
0610     u32 ts_wires = 0, adapt;
0611 
0612     ts = devm_kzalloc(dev, sizeof(*ts), GFP_KERNEL);
0613     if (!ts)
0614         return -ENOMEM;
0615 
0616     platform_set_drvdata(pdev, ts);
0617 
0618     ts->lradc = lradc;
0619     ts->dev = dev;
0620     spin_lock_init(&ts->lock);
0621 
0622     ts->base = devm_platform_ioremap_resource(pdev, 0);
0623     if (IS_ERR(ts->base))
0624         return PTR_ERR(ts->base);
0625 
0626     ret = of_property_read_u32(node, "fsl,lradc-touchscreen-wires",
0627                    &ts_wires);
0628     if (ret)
0629         return ret;
0630 
0631     if (of_property_read_u32(node, "fsl,ave-ctrl", &adapt)) {
0632         ts->over_sample_cnt = 4;
0633     } else {
0634         if (adapt >= 1 && adapt <= 32) {
0635             ts->over_sample_cnt = adapt;
0636         } else {
0637             dev_err(ts->dev, "Invalid sample count (%u)\n",
0638                 adapt);
0639             return -EINVAL;
0640         }
0641     }
0642 
0643     if (of_property_read_u32(node, "fsl,ave-delay", &adapt)) {
0644         ts->over_sample_delay = 2;
0645     } else {
0646         if (adapt >= 2 && adapt <= LRADC_DELAY_DELAY_MASK + 1) {
0647             ts->over_sample_delay = adapt;
0648         } else {
0649             dev_err(ts->dev, "Invalid sample delay (%u)\n",
0650                 adapt);
0651             return -EINVAL;
0652         }
0653     }
0654 
0655     if (of_property_read_u32(node, "fsl,settling", &adapt)) {
0656         ts->settling_delay = 10;
0657     } else {
0658         if (adapt >= 1 && adapt <= LRADC_DELAY_DELAY_MASK) {
0659             ts->settling_delay = adapt;
0660         } else {
0661             dev_err(ts->dev, "Invalid settling delay (%u)\n",
0662                 adapt);
0663             return -EINVAL;
0664         }
0665     }
0666 
0667     ret = stmp_reset_block(ts->base);
0668     if (ret)
0669         return ret;
0670 
0671     mxs_lradc_ts_hw_init(ts);
0672 
0673     for (i = 0; i < 3; i++) {
0674         irq = platform_get_irq_byname(pdev, mxs_lradc_ts_irq_names[i]);
0675         if (irq < 0)
0676             return irq;
0677 
0678         virq = irq_of_parse_and_map(node, irq);
0679 
0680         mxs_lradc_ts_stop(ts);
0681 
0682         ret = devm_request_irq(dev, virq,
0683                        mxs_lradc_ts_handle_irq,
0684                        0, mxs_lradc_ts_irq_names[i], ts);
0685         if (ret)
0686             return ret;
0687     }
0688 
0689     return mxs_lradc_ts_register(ts);
0690 }
0691 
0692 static struct platform_driver mxs_lradc_ts_driver = {
0693     .driver = {
0694         .name = "mxs-lradc-ts",
0695     },
0696     .probe  = mxs_lradc_ts_probe,
0697 };
0698 module_platform_driver(mxs_lradc_ts_driver);
0699 
0700 MODULE_AUTHOR("Marek Vasut <marex@denx.de>");
0701 MODULE_DESCRIPTION("Freescale MXS LRADC touchscreen driver");
0702 MODULE_LICENSE("GPL");
0703 MODULE_ALIAS("platform:mxs-lradc-ts");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!