source: trunk/target/linux/omap24xx/patches-2.6.38/600-tsc2005.patch @ 25746

Last change on this file since 25746 was 25746, checked in by mb, 6 years ago

omap24xx: Add 2.6.38 files

File size: 28.6 KB
  • drivers/input/touchscreen/Kconfig

    ---
     drivers/input/touchscreen/Kconfig   |   11 
     drivers/input/touchscreen/Makefile  |    1 
     drivers/input/touchscreen/tsc2005.c |  958 ++++++++++++++++++++++++++++++++++++
     include/linux/spi/tsc2005.h         |   30 +
     4 files changed, 1000 insertions(+)
    
    old new  
    629629          To compile this driver as a module, choose M here: the 
    630630          module will be called touchit213. 
    631631 
     632config TOUCHSCREEN_TSC2005 
     633        tristate "TSC2005 based touchscreens" 
     634        depends on SPI_MASTER 
     635        help 
     636          Say Y here if you have a TSC2005 based touchscreen. 
     637 
     638          If unsure, say N. 
     639 
     640          To compile this driver as a module, choose M here: the 
     641          module will be called tsc2005. 
     642 
    632643config TOUCHSCREEN_TSC2007 
    633644        tristate "TSC2007 based touchscreens" 
    634645        depends on I2C 
  • drivers/input/touchscreen/Makefile

    old new  
    4545obj-$(CONFIG_TOUCHSCREEN_TOUCHIT213)    += touchit213.o 
    4646obj-$(CONFIG_TOUCHSCREEN_TOUCHRIGHT)    += touchright.o 
    4747obj-$(CONFIG_TOUCHSCREEN_TOUCHWIN)      += touchwin.o 
     48obj-$(CONFIG_TOUCHSCREEN_TSC2005)       += tsc2005.o 
    4849obj-$(CONFIG_TOUCHSCREEN_TSC2007)       += tsc2007.o 
    4950obj-$(CONFIG_TOUCHSCREEN_UCB1400)       += ucb1400_ts.o 
    5051obj-$(CONFIG_TOUCHSCREEN_WACOM_W8001)   += wacom_w8001.o 
  • new file linux-2.6.38-rc6/drivers/input/touchscreen/tsc2005.c

    - +  
     1/* 
     2 * TSC2005 touchscreen driver 
     3 * 
     4 * Copyright (C) 2006-2008 Nokia Corporation 
     5 * 
     6 * Author: Lauri Leukkunen <lauri.leukkunen@nokia.com> 
     7 * based on TSC2301 driver by Klaus K. Pedersen <klaus.k.pedersen@nokia.com> 
     8 * 
     9 * This program is free software; you can redistribute it and/or modify 
     10 * it under the terms of the GNU General Public License as published by 
     11 * the Free Software Foundation; either version 2 of the License, or 
     12 * (at your option) any later version. 
     13 * 
     14 * This program is distributed in the hope that it will be useful, 
     15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 
     16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 
     17 * GNU General Public License for more details. 
     18 * 
     19 * You should have received a copy of the GNU General Public License 
     20 * along with this program; if not, write to the Free Software 
     21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
     22 * 
     23 */ 
     24 
     25#include <linux/kernel.h> 
     26#include <linux/module.h> 
     27#include <linux/input.h> 
     28#include <linux/interrupt.h> 
     29#include <linux/delay.h> 
     30#include <linux/spi/spi.h> 
     31 
     32#include <linux/spi/tsc2005.h> 
     33 
     34/** 
     35 * The touchscreen interface operates as follows: 
     36 * 
     37 * Initialize: 
     38 *    Request access to GPIO103 (DAV) 
     39 *    tsc2005_ts_irq_handler will trigger when DAV line goes down 
     40 * 
     41 *  1) Pen is pressed against touchscreeen 
     42 *  2) TSC2005 performs AD conversion 
     43 *  3) After the conversion is done TSC2005 drives DAV line down 
     44 *  4) GPIO IRQ is received and tsc2005_ts_irq_handler is called 
     45 *  5) tsc2005_ts_irq_handler queues up an spi transfer to fetch 
     46 *     the x, y, z1, z2 values 
     47 *  6) tsc2005_ts_rx() reports coordinates to input layer and 
     48 *     sets up tsc2005_ts_timer() to be called after TSC2005_TS_SCAN_TIME 
     49 *  7)  When the penup_timer expires, there have not been DAV interrupts 
     50 *     during the last 20ms which means the pen has been lifted. 
     51 */ 
     52 
     53#define TSC2005_VDD_LOWER_27 
     54 
     55#ifdef TSC2005_VDD_LOWER_27 
     56#define TSC2005_HZ     (10000000) 
     57#else 
     58#define TSC2005_HZ     (25000000) 
     59#endif 
     60 
     61#define TSC2005_CMD     (0x80) 
     62#define TSC2005_REG     (0x00) 
     63 
     64#define TSC2005_CMD_STOP        (1) 
     65#define TSC2005_CMD_10BIT       (0 << 2) 
     66#define TSC2005_CMD_12BIT       (1 << 2) 
     67 
     68#define TSC2005_CMD_SCAN_XYZZ   (0 << 3) 
     69#define TSC2005_CMD_SCAN_XY     (1 << 3) 
     70#define TSC2005_CMD_SCAN_X      (2 << 3) 
     71#define TSC2005_CMD_SCAN_Y      (3 << 3) 
     72#define TSC2005_CMD_SCAN_ZZ     (4 << 3) 
     73#define TSC2005_CMD_AUX_SINGLE  (5 << 3) 
     74#define TSC2005_CMD_TEMP1       (6 << 3) 
     75#define TSC2005_CMD_TEMP2       (7 << 3) 
     76#define TSC2005_CMD_AUX_CONT    (8 << 3) 
     77#define TSC2005_CMD_TEST_X_CONN (9 << 3) 
     78#define TSC2005_CMD_TEST_Y_CONN (10 << 3) 
     79#define TSC2005_CMD_TEST_SHORT  (11 << 3) 
     80/* command 12 reserved, according to 2008-03 erratum */ 
     81#define TSC2005_CMD_DRIVE_XX    (13 << 3) 
     82#define TSC2005_CMD_DRIVE_YY    (14 << 3) 
     83#define TSC2005_CMD_DRIVE_YX    (15 << 3) 
     84 
     85#define TSC2005_REG_X           (0 << 3) 
     86#define TSC2005_REG_Y           (1 << 3) 
     87#define TSC2005_REG_Z1          (2 << 3) 
     88#define TSC2005_REG_Z2          (3 << 3) 
     89#define TSC2005_REG_AUX         (4 << 3) 
     90#define TSC2005_REG_TEMP1       (5 << 3) 
     91#define TSC2005_REG_TEMP2       (6 << 3) 
     92#define TSC2005_REG_STATUS      (7 << 3) 
     93#define TSC2005_REG_AUX_HIGH    (8 << 3) 
     94#define TSC2005_REG_AUX_LOW     (9 << 3) 
     95#define TSC2005_REG_TEMP_HIGH   (10 << 3) 
     96#define TSC2005_REG_TEMP_LOW    (11 << 3) 
     97#define TSC2005_REG_CFR0        (12 << 3) 
     98#define TSC2005_REG_CFR1        (13 << 3) 
     99#define TSC2005_REG_CFR2        (14 << 3) 
     100#define TSC2005_REG_FUNCTION    (15 << 3) 
     101 
     102#define TSC2005_REG_PND0        (1 << 1) 
     103#define TSC2005_REG_READ        (0x01) 
     104#define TSC2005_REG_WRITE       (0x00) 
     105 
     106 
     107#define TSC2005_CFR0_LONGSAMPLING       (1) 
     108#define TSC2005_CFR0_DETECTINWAIT       (1 << 1) 
     109#define TSC2005_CFR0_SENSETIME_32US     (0) 
     110#define TSC2005_CFR0_SENSETIME_96US     (1 << 2) 
     111#define TSC2005_CFR0_SENSETIME_544US    (1 << 3) 
     112#define TSC2005_CFR0_SENSETIME_2080US   (1 << 4) 
     113#define TSC2005_CFR0_SENSETIME_2656US   (0x001C) 
     114#define TSC2005_CFR0_PRECHARGE_20US     (0x0000) 
     115#define TSC2005_CFR0_PRECHARGE_84US     (0x0020) 
     116#define TSC2005_CFR0_PRECHARGE_276US    (0x0040) 
     117#define TSC2005_CFR0_PRECHARGE_1044US   (0x0080) 
     118#define TSC2005_CFR0_PRECHARGE_1364US   (0x00E0) 
     119#define TSC2005_CFR0_STABTIME_0US       (0x0000) 
     120#define TSC2005_CFR0_STABTIME_100US     (0x0100) 
     121#define TSC2005_CFR0_STABTIME_500US     (0x0200) 
     122#define TSC2005_CFR0_STABTIME_1MS       (0x0300) 
     123#define TSC2005_CFR0_STABTIME_5MS       (0x0400) 
     124#define TSC2005_CFR0_STABTIME_100MS     (0x0700) 
     125#define TSC2005_CFR0_CLOCK_4MHZ         (0x0000) 
     126#define TSC2005_CFR0_CLOCK_2MHZ         (0x0800) 
     127#define TSC2005_CFR0_CLOCK_1MHZ         (0x1000) 
     128#define TSC2005_CFR0_RESOLUTION12       (0x2000) 
     129#define TSC2005_CFR0_STATUS             (0x4000) 
     130#define TSC2005_CFR0_PENMODE            (0x8000) 
     131 
     132#define TSC2005_CFR0_INITVALUE  (TSC2005_CFR0_STABTIME_1MS  |   \ 
     133                                 TSC2005_CFR0_CLOCK_1MHZ    |   \ 
     134                                 TSC2005_CFR0_RESOLUTION12  |   \ 
     135                                 TSC2005_CFR0_PRECHARGE_276US | \ 
     136                                 TSC2005_CFR0_PENMODE) 
     137 
     138/* Bits common to both read and write of config register 0 */ 
     139#define TSC2005_CFR0_RW_MASK    0x3fff 
     140 
     141#define TSC2005_CFR1_BATCHDELAY_0MS     (0x0000) 
     142#define TSC2005_CFR1_BATCHDELAY_1MS     (0x0001) 
     143#define TSC2005_CFR1_BATCHDELAY_2MS     (0x0002) 
     144#define TSC2005_CFR1_BATCHDELAY_4MS     (0x0003) 
     145#define TSC2005_CFR1_BATCHDELAY_10MS    (0x0004) 
     146#define TSC2005_CFR1_BATCHDELAY_20MS    (0x0005) 
     147#define TSC2005_CFR1_BATCHDELAY_40MS    (0x0006) 
     148#define TSC2005_CFR1_BATCHDELAY_100MS   (0x0007) 
     149 
     150#define TSC2005_CFR1_INITVALUE  (TSC2005_CFR1_BATCHDELAY_4MS) 
     151 
     152#define TSC2005_CFR2_MAVE_TEMP  (0x0001) 
     153#define TSC2005_CFR2_MAVE_AUX   (0x0002) 
     154#define TSC2005_CFR2_MAVE_Z     (0x0004) 
     155#define TSC2005_CFR2_MAVE_Y     (0x0008) 
     156#define TSC2005_CFR2_MAVE_X     (0x0010) 
     157#define TSC2005_CFR2_AVG_1      (0x0000) 
     158#define TSC2005_CFR2_AVG_3      (0x0400) 
     159#define TSC2005_CFR2_AVG_7      (0x0800) 
     160#define TSC2005_CFR2_MEDIUM_1   (0x0000) 
     161#define TSC2005_CFR2_MEDIUM_3   (0x1000) 
     162#define TSC2005_CFR2_MEDIUM_7   (0x2000) 
     163#define TSC2005_CFR2_MEDIUM_15  (0x3000) 
     164 
     165#define TSC2005_CFR2_IRQ_MASK   (0xC000) 
     166#define TSC2005_CFR2_IRQ_DAV    (0x4000) 
     167#define TSC2005_CFR2_IRQ_PEN    (0x8000) 
     168#define TSC2005_CFR2_IRQ_PENDAV (0x0000) 
     169 
     170#define TSC2005_CFR2_INITVALUE  (TSC2005_CFR2_IRQ_PENDAV |      \ 
     171                                 TSC2005_CFR2_MAVE_X    |       \ 
     172                                 TSC2005_CFR2_MAVE_Y    |       \ 
     173                                 TSC2005_CFR2_MAVE_Z    |       \ 
     174                                 TSC2005_CFR2_MEDIUM_15 |       \ 
     175                                 TSC2005_CFR2_AVG_7) 
     176 
     177#define MAX_12BIT                                       ((1 << 12) - 1) 
     178#define TS_SAMPLES                                      4 
     179#define TSC2005_TS_PENUP_TIME                           40 
     180 
     181static const u32 tsc2005_read_reg[] = { 
     182        (TSC2005_REG | TSC2005_REG_X | TSC2005_REG_READ) << 16, 
     183        (TSC2005_REG | TSC2005_REG_Y | TSC2005_REG_READ) << 16, 
     184        (TSC2005_REG | TSC2005_REG_Z1 | TSC2005_REG_READ) << 16, 
     185        (TSC2005_REG | TSC2005_REG_Z2 | TSC2005_REG_READ) << 16, 
     186}; 
     187#define NUM_READ_REGS   (sizeof(tsc2005_read_reg)/sizeof(tsc2005_read_reg[0])) 
     188 
     189struct tsc2005 { 
     190        struct spi_device       *spi; 
     191 
     192        struct input_dev        *idev; 
     193        char                    phys[32]; 
     194        struct timer_list       penup_timer; 
     195 
     196        /* ESD recovery via a hardware reset if the tsc2005 
     197         * doesn't respond after a configurable period (in ms) of 
     198         * IRQ/SPI inactivity. If esd_timeout is 0, timer and work 
     199         * fields are used. 
     200         */ 
     201        u32                     esd_timeout; 
     202        struct timer_list       esd_timer; 
     203        struct work_struct      esd_work; 
     204 
     205        spinlock_t              lock; 
     206        struct mutex            mutex; 
     207 
     208        struct spi_message      read_msg; 
     209        struct spi_transfer     read_xfer[NUM_READ_REGS]; 
     210        u32                     data[NUM_READ_REGS]; 
     211 
     212        /* previously reported x,y,p (if pen_down) */ 
     213        int                     out_x; 
     214        int                     out_y; 
     215        int                     out_p; 
     216        /* fudge parameters - changes must exceed one of these. */ 
     217        int                     fudge_x; 
     218        int                     fudge_y; 
     219        int                     fudge_p; 
     220        /* raw copy of previous x,y,z */ 
     221        int                     in_x; 
     222        int                     in_y; 
     223        int                     in_z1; 
     224        int                     in_z2; 
     225        /* average accumulators for each component */ 
     226        int                     sample_cnt; 
     227        int                     avg_x; 
     228        int                     avg_y; 
     229        int                     avg_z1; 
     230        int                     avg_z2; 
     231        /* configuration */ 
     232        int                     x_plate_ohm; 
     233        int                     hw_avg_max; 
     234        int                     stab_time; 
     235        int                     p_max; 
     236        int                     touch_pressure; 
     237        /* status */ 
     238        u8                      sample_sent; 
     239        u8                      pen_down; 
     240        u8                      disabled; 
     241        u8                      disable_depth; 
     242        u8                      spi_pending; 
     243 
     244        void (*set_reset)(bool enable); 
     245}; 
     246 
     247static void tsc2005_cmd(struct tsc2005 *ts, u8 cmd) 
     248{ 
     249        u8 data = TSC2005_CMD | TSC2005_CMD_12BIT | cmd; 
     250        struct spi_message msg; 
     251        struct spi_transfer xfer = { 0 }; 
     252 
     253        xfer.tx_buf = &data; 
     254        xfer.rx_buf = NULL; 
     255        xfer.len = 1; 
     256        xfer.bits_per_word = 8; 
     257 
     258        spi_message_init(&msg); 
     259        spi_message_add_tail(&xfer, &msg); 
     260        spi_sync(ts->spi, &msg); 
     261} 
     262 
     263static void tsc2005_write(struct tsc2005 *ts, u8 reg, u16 value) 
     264{ 
     265        u32 tx; 
     266        struct spi_message msg; 
     267        struct spi_transfer xfer = { 0 }; 
     268 
     269        tx = (TSC2005_REG | reg | TSC2005_REG_PND0 | 
     270               TSC2005_REG_WRITE) << 16; 
     271        tx |= value; 
     272 
     273        xfer.tx_buf = &tx; 
     274        xfer.rx_buf = NULL; 
     275        xfer.len = 4; 
     276        xfer.bits_per_word = 24; 
     277 
     278        spi_message_init(&msg); 
     279        spi_message_add_tail(&xfer, &msg); 
     280        spi_sync(ts->spi, &msg); 
     281} 
     282 
     283static void tsc2005_read(struct tsc2005 *ts, u8 reg, u16 *value) 
     284{ 
     285        u32 tx; 
     286        u32 rx = 0; 
     287        struct spi_message msg; 
     288        struct spi_transfer xfer = { 0 }; 
     289 
     290        tx = (TSC2005_REG | reg | TSC2005_REG_READ) << 16; 
     291 
     292        xfer.tx_buf = &tx; 
     293        xfer.rx_buf = &rx; 
     294        xfer.len = 4; 
     295        xfer.bits_per_word = 24; 
     296 
     297        spi_message_init(&msg); 
     298        spi_message_add_tail(&xfer, &msg); 
     299        spi_sync(ts->spi, &msg); 
     300        *value = rx; 
     301} 
     302 
     303static void tsc2005_ts_update_pen_state(struct tsc2005 *ts, 
     304                                        int x, int y, int pressure) 
     305{ 
     306        if (pressure) { 
     307                input_report_abs(ts->idev, ABS_X, x); 
     308                input_report_abs(ts->idev, ABS_Y, y); 
     309                input_report_abs(ts->idev, ABS_PRESSURE, pressure); 
     310                if (!ts->pen_down) { 
     311                        input_report_key(ts->idev, BTN_TOUCH, 1); 
     312                        ts->pen_down = 1; 
     313                } 
     314        } else { 
     315                input_report_abs(ts->idev, ABS_PRESSURE, 0); 
     316                if (ts->pen_down) { 
     317                        input_report_key(ts->idev, BTN_TOUCH, 0); 
     318                        ts->pen_down = 0; 
     319                } 
     320        } 
     321 
     322        input_sync(ts->idev); 
     323} 
     324 
     325/* 
     326 * This function is called by the SPI framework after the coordinates 
     327 * have been read from TSC2005 
     328 */ 
     329static void tsc2005_ts_rx(void *arg) 
     330{ 
     331        struct tsc2005 *ts = arg; 
     332        unsigned long flags; 
     333        int inside_rect, pressure_limit; 
     334        int x, y, z1, z2, pressure; 
     335 
     336        spin_lock_irqsave(&ts->lock, flags); 
     337 
     338        if (ts->disable_depth) { 
     339                ts->spi_pending = 0; 
     340                goto out; 
     341        } 
     342 
     343        x = ts->data[0]; 
     344        y = ts->data[1]; 
     345        z1 = ts->data[2]; 
     346        z2 = ts->data[3]; 
     347 
     348        /* validate pressure and position */ 
     349        if (x > MAX_12BIT || y > MAX_12BIT) 
     350                goto out; 
     351 
     352        /* skip coords if the pressure-components are out of range */ 
     353        if (z1 < 100 || z2 > MAX_12BIT || z1 >= z2) 
     354                goto out; 
     355 
     356        /* skip point if this is a pen down with the exact same values as 
     357         * the value before pen-up - that implies SPI fed us stale data 
     358         */ 
     359        if (!ts->pen_down && 
     360            ts->in_x == x && 
     361            ts->in_y == y && 
     362            ts->in_z1 == z1 && 
     363            ts->in_z2 == z2) 
     364                goto out; 
     365 
     366        /* At this point we are happy we have a valid and useful reading. 
     367         * Remember it for later comparisons. We may now begin downsampling 
     368         */ 
     369        ts->in_x = x; 
     370        ts->in_y = y; 
     371        ts->in_z1 = z1; 
     372        ts->in_z2 = z2; 
     373 
     374        /* don't run average on the "pen down" event */ 
     375        if (ts->sample_sent) { 
     376                ts->avg_x += x; 
     377                ts->avg_y += y; 
     378                ts->avg_z1 += z1; 
     379                ts->avg_z2 += z2; 
     380 
     381                if (++ts->sample_cnt < TS_SAMPLES) 
     382                        goto out; 
     383 
     384                x = ts->avg_x / TS_SAMPLES; 
     385                y = ts->avg_y / TS_SAMPLES; 
     386                z1 = ts->avg_z1 / TS_SAMPLES; 
     387                z2 = ts->avg_z2 / TS_SAMPLES; 
     388        } 
     389 
     390        ts->sample_cnt = 0; 
     391        ts->avg_x = 0; 
     392        ts->avg_y = 0; 
     393        ts->avg_z1 = 0; 
     394        ts->avg_z2 = 0; 
     395 
     396        pressure = x * (z2 - z1) / z1; 
     397        pressure = pressure * ts->x_plate_ohm / 4096; 
     398 
     399        pressure_limit = ts->sample_sent ? ts->p_max : ts->touch_pressure; 
     400        if (pressure > pressure_limit) 
     401                goto out; 
     402 
     403        /* Discard the event if it still is within the previous rect - 
     404         * unless the pressure is clearly harder, but then use previous 
     405         * x,y position. If any coordinate deviates enough, fudging 
     406         * of all three will still take place in the input layer. 
     407         */ 
     408        inside_rect = (ts->sample_sent && 
     409                x > (int)ts->out_x - ts->fudge_x && 
     410                x < (int)ts->out_x + ts->fudge_x && 
     411                y > (int)ts->out_y - ts->fudge_y && 
     412                y < (int)ts->out_y + ts->fudge_y); 
     413        if (inside_rect) 
     414                x = ts->out_x, y = ts->out_y; 
     415 
     416        if (!inside_rect || pressure < (ts->out_p - ts->fudge_p)) { 
     417                tsc2005_ts_update_pen_state(ts, x, y, pressure); 
     418                ts->sample_sent = 1; 
     419                ts->out_x = x; 
     420                ts->out_y = y; 
     421                ts->out_p = pressure; 
     422        } 
     423out: 
     424        if (ts->spi_pending > 1) { 
     425                /* One or more interrupts (sometimes several dozens) 
     426                 * occured while waiting for the SPI read - get 
     427                 * another read going. 
     428                 */ 
     429                ts->spi_pending = 1; 
     430                if (spi_async(ts->spi, &ts->read_msg)) { 
     431                        dev_err(&ts->spi->dev, "ts: spi_async() failed"); 
     432                        ts->spi_pending = 0; 
     433                } 
     434        } else 
     435                ts->spi_pending = 0; 
     436 
     437        /* kick pen up timer - to make sure it expires again(!) */ 
     438        if (ts->sample_sent) { 
     439                mod_timer(&ts->penup_timer, 
     440                          jiffies + msecs_to_jiffies(TSC2005_TS_PENUP_TIME)); 
     441                /* Also kick the watchdog, as we still think we're alive */ 
     442                if (ts->esd_timeout && ts->disable_depth == 0) { 
     443                        unsigned long wdj = msecs_to_jiffies(ts->esd_timeout); 
     444                        mod_timer(&ts->esd_timer, round_jiffies(jiffies+wdj)); 
     445                } 
     446        } 
     447        spin_unlock_irqrestore(&ts->lock, flags); 
     448} 
     449 
     450/* This penup timer is very forgiving of delayed SPI reads. The 
     451 * (ESD) watchdog will rescue us if spi_pending remains set, unless 
     452 * we are enterring the disabled state. In that case we must just 
     453 * handle the pen up, and let disabling complete. 
     454 */ 
     455static void tsc2005_ts_penup_timer_handler(unsigned long data) 
     456{ 
     457        struct tsc2005 *ts = (struct tsc2005 *)data; 
     458        if ((!ts->spi_pending || ts->disable_depth) && 
     459            ts->sample_sent) { 
     460                tsc2005_ts_update_pen_state(ts, 0, 0, 0); 
     461                ts->sample_sent = 0; 
     462        } 
     463} 
     464 
     465/* 
     466 * This interrupt is called when pen is down and coordinates are 
     467 * available. That is indicated by a either: 
     468 * a) a rising edge on PINTDAV or (PENDAV mode) 
     469 * b) a falling edge on DAV line (DAV mode) 
     470 * depending on the setting of the IRQ bits in the CFR2 setting above. 
     471 */ 
     472static irqreturn_t tsc2005_ts_irq_handler(int irq, void *dev_id) 
     473{ 
     474        struct tsc2005 *ts = dev_id; 
     475        if (ts->disable_depth) 
     476                goto out; 
     477 
     478        if (!ts->spi_pending) { 
     479                if (spi_async(ts->spi, &ts->read_msg)) { 
     480                        dev_err(&ts->spi->dev, "ts: spi_async() failed"); 
     481                        goto out; 
     482                } 
     483        } 
     484        /* By shifting in 1s we can never wrap */ 
     485        ts->spi_pending = (ts->spi_pending<<1)+1; 
     486 
     487        /* Kick pen up timer only if it's not been started yet. Strictly, 
     488         * it isn't even necessary to start it at all here,  but doing so 
     489         * keeps an equivalence between pen state and timer state. 
     490         * The SPI read loop will keep pushing it into the future. 
     491         * If it times out with an SPI pending, it's ignored anyway. 
     492         */ 
     493        if (!timer_pending(&ts->penup_timer)) { 
     494                unsigned long pu = msecs_to_jiffies(TSC2005_TS_PENUP_TIME); 
     495                ts->penup_timer.expires = jiffies + pu; 
     496                add_timer(&ts->penup_timer); 
     497        } 
     498out: 
     499        return IRQ_HANDLED; 
     500} 
     501 
     502static void tsc2005_ts_setup_spi_xfer(struct tsc2005 *ts) 
     503{ 
     504        struct spi_message *m = &ts->read_msg; 
     505        struct spi_transfer *x = &ts->read_xfer[0]; 
     506        int i; 
     507 
     508        spi_message_init(m); 
     509 
     510        for (i = 0; i < NUM_READ_REGS; i++, x++) { 
     511                x->tx_buf = &tsc2005_read_reg[i]; 
     512                x->rx_buf = &ts->data[i]; 
     513                x->len = 4; 
     514                x->bits_per_word = 24; 
     515                x->cs_change = i < (NUM_READ_REGS - 1); 
     516                spi_message_add_tail(x, m); 
     517        } 
     518 
     519        m->complete = tsc2005_ts_rx; 
     520        m->context = ts; 
     521} 
     522 
     523static ssize_t tsc2005_ts_pen_down_show(struct device *dev, 
     524                                        struct device_attribute *attr, 
     525                                        char *buf) 
     526{ 
     527        struct tsc2005 *ts = dev_get_drvdata(dev); 
     528 
     529        return sprintf(buf, "%u\n", ts->pen_down); 
     530} 
     531 
     532static DEVICE_ATTR(pen_down, S_IRUGO, tsc2005_ts_pen_down_show, NULL); 
     533 
     534static int tsc2005_configure(struct tsc2005 *ts, int flags) 
     535{ 
     536        tsc2005_write(ts, TSC2005_REG_CFR0, TSC2005_CFR0_INITVALUE); 
     537        tsc2005_write(ts, TSC2005_REG_CFR1, TSC2005_CFR1_INITVALUE); 
     538        tsc2005_write(ts, TSC2005_REG_CFR2, TSC2005_CFR2_INITVALUE); 
     539        tsc2005_cmd(ts, flags); 
     540 
     541        return 0; 
     542} 
     543 
     544static void tsc2005_start_scan(struct tsc2005 *ts) 
     545{ 
     546        tsc2005_configure(ts, TSC2005_CMD_SCAN_XYZZ); 
     547} 
     548 
     549static void tsc2005_stop_scan(struct tsc2005 *ts) 
     550{ 
     551        tsc2005_cmd(ts, TSC2005_CMD_STOP); 
     552} 
     553 
     554/* Must be called with mutex held */ 
     555static void tsc2005_disable(struct tsc2005 *ts) 
     556{ 
     557        if (ts->disable_depth++ != 0) 
     558                return; 
     559 
     560        disable_irq(ts->spi->irq); 
     561        if (ts->esd_timeout) 
     562                del_timer(&ts->esd_timer); 
     563 
     564        /* wait until penup timer expire normally */ 
     565        do { 
     566                msleep(4); 
     567        } while (ts->sample_sent); 
     568 
     569        tsc2005_stop_scan(ts); 
     570} 
     571 
     572static void tsc2005_enable(struct tsc2005 *ts) 
     573{ 
     574        if (ts->disable_depth != 1) 
     575                goto out; 
     576 
     577        if (ts->esd_timeout) { 
     578                unsigned long wdj = msecs_to_jiffies(ts->esd_timeout); 
     579                ts->esd_timer.expires = round_jiffies(jiffies+wdj); 
     580                add_timer(&ts->esd_timer); 
     581        } 
     582        tsc2005_start_scan(ts); 
     583        enable_irq(ts->spi->irq); 
     584out: 
     585        --ts->disable_depth; 
     586} 
     587 
     588static ssize_t tsc2005_disable_show(struct device *dev, 
     589                                    struct device_attribute *attr, char *buf) 
     590{ 
     591        struct tsc2005 *ts = dev_get_drvdata(dev); 
     592 
     593        return sprintf(buf, "%u\n", ts->disabled); 
     594} 
     595 
     596static ssize_t tsc2005_disable_store(struct device *dev, 
     597                                     struct device_attribute *attr, 
     598                                     const char *buf, size_t count) 
     599{ 
     600        struct tsc2005          *ts = dev_get_drvdata(dev); 
     601        unsigned long res; 
     602        int i; 
     603 
     604        if (strict_strtoul(buf, 10, &res) < 0) 
     605                return -EINVAL; 
     606        i = res ? 1 : 0; 
     607 
     608        mutex_lock(&ts->mutex); 
     609        if (i == ts->disabled) 
     610                goto out; 
     611        ts->disabled = i; 
     612 
     613        if (i) 
     614                tsc2005_disable(ts); 
     615        else 
     616                tsc2005_enable(ts); 
     617out: 
     618        mutex_unlock(&ts->mutex); 
     619        return count; 
     620} 
     621 
     622static DEVICE_ATTR(disable_ts, 0664, tsc2005_disable_show, 
     623                   tsc2005_disable_store); 
     624 
     625static ssize_t tsc2005_ctrl_selftest_show(struct device *dev, 
     626                                          struct device_attribute *attr, 
     627                                          char *buf) 
     628{ 
     629        u16 temp_high_orig, temp_high_test, temp_high; 
     630        unsigned int result = 1; 
     631        struct tsc2005 *ts = dev_get_drvdata(dev); 
     632 
     633        if (!ts->set_reset) { 
     634                dev_warn(&ts->spi->dev, 
     635                         "unable to selftest: reset not configured\n"); 
     636                result = 0; 
     637                goto out; 
     638        } 
     639 
     640        mutex_lock(&ts->mutex); 
     641        tsc2005_disable(ts); 
     642 
     643        /* Test ctrl communications via temp high / low registers */ 
     644        tsc2005_read(ts, TSC2005_REG_TEMP_HIGH, &temp_high_orig); 
     645 
     646        temp_high_test = (temp_high_orig - 1) & 0x0FFF; 
     647 
     648        tsc2005_write(ts, TSC2005_REG_TEMP_HIGH, temp_high_test); 
     649 
     650        tsc2005_read(ts, TSC2005_REG_TEMP_HIGH, &temp_high); 
     651 
     652        if (temp_high != temp_high_test) { 
     653                result = 0; 
     654                dev_warn(dev, "selftest failed: %d != %d\n", 
     655                         temp_high, temp_high_test); 
     656        } 
     657 
     658        /* HW Reset */ 
     659        ts->set_reset(0); 
     660        msleep(1); /* only 10us required */ 
     661        ts->set_reset(1); 
     662 
     663        tsc2005_enable(ts); 
     664 
     665        /* Test that reset really happened */ 
     666        tsc2005_read(ts, TSC2005_REG_TEMP_HIGH, &temp_high); 
     667 
     668        if (temp_high != temp_high_orig) { 
     669                result = 0; 
     670                dev_warn(dev, "selftest failed after reset: " 
     671                         "%d != %d\n", 
     672                         temp_high, temp_high_orig); 
     673        } 
     674 
     675        mutex_unlock(&ts->mutex); 
     676 
     677out: 
     678        return sprintf(buf, "%u\n", result); 
     679} 
     680 
     681static DEVICE_ATTR(ts_ctrl_selftest, S_IRUGO, tsc2005_ctrl_selftest_show, NULL); 
     682 
     683static void tsc2005_esd_timer_handler(unsigned long data) 
     684{ 
     685        struct tsc2005 *ts = (struct tsc2005 *)data; 
     686        if (!ts->disable_depth) 
     687                schedule_work(&ts->esd_work); 
     688} 
     689 
     690static void tsc2005_rst_handler(struct work_struct *work) 
     691{ 
     692        u16 reg_val; 
     693        struct tsc2005 *ts = container_of(work, struct tsc2005, esd_work); 
     694        unsigned long wdj; 
     695 
     696        mutex_lock(&ts->mutex); 
     697 
     698        /* If we are disabled, or the a touch has been detected, 
     699         * then ignore this timeout. The enable will restart the 
     700         * watchdog, as it restarts scanning 
     701         */ 
     702        if (ts->disable_depth) 
     703                goto out; 
     704 
     705        /* If we cannot read our known value from configuration register 0 
     706         * then reset the controller as if from power-up and start 
     707         * scanning again. Always re-arm the watchdog. 
     708         */ 
     709        tsc2005_read(ts, TSC2005_REG_CFR0, &reg_val); 
     710        if ((reg_val ^ TSC2005_CFR0_INITVALUE) & TSC2005_CFR0_RW_MASK) { 
     711                dev_info(&ts->spi->dev, "TSC not responding, resetting.\n"); 
     712                /* If this timer kicked in, the penup timer, if ever active 
     713                 * at all, must have expired ages ago, so no need to del it. 
     714                 */ 
     715                ts->set_reset(0); 
     716                if (ts->sample_sent) { 
     717                        tsc2005_ts_update_pen_state(ts, 0, 0, 0); 
     718                        ts->sample_sent = 0; 
     719                } 
     720                ts->spi_pending = 0; 
     721                msleep(1); /* only 10us required */ 
     722                ts->set_reset(1); 
     723                tsc2005_start_scan(ts); 
     724        } 
     725        wdj = msecs_to_jiffies(ts->esd_timeout); 
     726        mod_timer(&ts->esd_timer, round_jiffies(jiffies+wdj)); 
     727 
     728out: 
     729        mutex_unlock(&ts->mutex); 
     730} 
     731 
     732static int __devinit tsc2005_ts_init(struct tsc2005 *ts, 
     733                                     struct tsc2005_platform_data *pdata) 
     734{ 
     735        struct input_dev *idev; 
     736        int r; 
     737        int x_max, y_max; 
     738 
     739        init_timer(&ts->penup_timer); 
     740        setup_timer(&ts->penup_timer, tsc2005_ts_penup_timer_handler, 
     741                        (unsigned long)ts); 
     742 
     743        spin_lock_init(&ts->lock); 
     744        mutex_init(&ts->mutex); 
     745 
     746        ts->x_plate_ohm         = pdata->ts_x_plate_ohm ? : 280; 
     747        ts->hw_avg_max          = pdata->ts_hw_avg; 
     748        ts->stab_time           = pdata->ts_stab_time; 
     749        x_max                   = pdata->ts_x_max ? : 4096; 
     750        ts->fudge_x             = pdata->ts_x_fudge ? : 4; 
     751        y_max                   = pdata->ts_y_max ? : 4096; 
     752        ts->fudge_y             = pdata->ts_y_fudge ? : 8; 
     753        ts->p_max               = pdata->ts_pressure_max ? : MAX_12BIT; 
     754        ts->touch_pressure      = pdata->ts_touch_pressure ? : ts->p_max; 
     755        ts->fudge_p             = pdata->ts_pressure_fudge ? : 2; 
     756 
     757        ts->set_reset           = pdata->set_reset; 
     758 
     759        idev = input_allocate_device(); 
     760        if (idev == NULL) { 
     761                r = -ENOMEM; 
     762                goto err1; 
     763        } 
     764 
     765        idev->name = "TSC2005 touchscreen"; 
     766        snprintf(ts->phys, sizeof(ts->phys), "%s/input-ts", 
     767                 dev_name(&ts->spi->dev)); 
     768        idev->phys = ts->phys; 
     769 
     770        idev->evbit[0] = BIT(EV_ABS) | BIT(EV_KEY); 
     771        idev->absbit[0] = BIT(ABS_X) | BIT(ABS_Y) | BIT(ABS_PRESSURE); 
     772        idev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH); 
     773        ts->idev = idev; 
     774 
     775        tsc2005_ts_setup_spi_xfer(ts); 
     776 
     777        input_set_abs_params(idev, ABS_X, 0, x_max, ts->fudge_x, 0); 
     778        input_set_abs_params(idev, ABS_Y, 0, y_max, ts->fudge_y, 0); 
     779        input_set_abs_params(idev, ABS_PRESSURE, 0, ts->p_max, ts->fudge_p, 0); 
     780 
     781        tsc2005_start_scan(ts); 
     782 
     783        r = request_irq(ts->spi->irq, tsc2005_ts_irq_handler, 
     784                        (((TSC2005_CFR2_INITVALUE & TSC2005_CFR2_IRQ_MASK) == 
     785                          TSC2005_CFR2_IRQ_PENDAV) 
     786                         ? IRQF_TRIGGER_RISING 
     787                         : IRQF_TRIGGER_FALLING) | 
     788                        IRQF_DISABLED, "tsc2005", ts); 
     789        if (r < 0) { 
     790                dev_err(&ts->spi->dev, "unable to get DAV IRQ"); 
     791                goto err2; 
     792        } 
     793 
     794        set_irq_wake(ts->spi->irq, 1); 
     795 
     796        r = input_register_device(idev); 
     797        if (r < 0) { 
     798                dev_err(&ts->spi->dev, "can't register touchscreen device\n"); 
     799                goto err3; 
     800        } 
     801 
     802        /* We can tolerate these failing */ 
     803        r = device_create_file(&ts->spi->dev, &dev_attr_ts_ctrl_selftest); 
     804        if (r < 0) 
     805                dev_warn(&ts->spi->dev, "can't create sysfs file for %s: %d\n", 
     806                         dev_attr_ts_ctrl_selftest.attr.name, r); 
     807 
     808        r = device_create_file(&ts->spi->dev, &dev_attr_pen_down); 
     809        if (r < 0) 
     810                dev_warn(&ts->spi->dev, "can't create sysfs file for %s: %d\n", 
     811                         dev_attr_pen_down.attr.name, r); 
     812 
     813        r = device_create_file(&ts->spi->dev, &dev_attr_disable_ts); 
     814        if (r < 0) 
     815                dev_warn(&ts->spi->dev, "can't create sysfs file for %s: %d\n", 
     816                         dev_attr_disable_ts.attr.name, r); 
     817 
     818        /* Finally, configure and start the optional EDD watchdog. */ 
     819        ts->esd_timeout = pdata->esd_timeout; 
     820        if (ts->esd_timeout && ts->set_reset) { 
     821                unsigned long wdj; 
     822                setup_timer(&ts->esd_timer, tsc2005_esd_timer_handler, 
     823                            (unsigned long)ts); 
     824                INIT_WORK(&ts->esd_work, tsc2005_rst_handler); 
     825                wdj = msecs_to_jiffies(ts->esd_timeout); 
     826                ts->esd_timer.expires = round_jiffies(jiffies+wdj); 
     827                add_timer(&ts->esd_timer); 
     828        } 
     829 
     830        return 0; 
     831err3: 
     832        free_irq(ts->spi->irq, ts); 
     833err2: 
     834        tsc2005_stop_scan(ts); 
     835        input_free_device(idev); 
     836err1: 
     837        return r; 
     838} 
     839 
     840static int __devinit tsc2005_probe(struct spi_device *spi) 
     841{ 
     842        struct tsc2005                  *ts; 
     843        struct tsc2005_platform_data    *pdata = spi->dev.platform_data; 
     844        int r; 
     845 
     846        if (spi->irq < 0) { 
     847                dev_dbg(&spi->dev, "no irq?\n"); 
     848                return -ENODEV; 
     849        } 
     850        if (!pdata) { 
     851                dev_dbg(&spi->dev, "no platform data?\n"); 
     852                return -ENODEV; 
     853        } 
     854 
     855        ts = kzalloc(sizeof(*ts), GFP_KERNEL); 
     856        if (ts == NULL) 
     857                return -ENOMEM; 
     858 
     859        dev_set_drvdata(&spi->dev, ts); 
     860        ts->spi = spi; 
     861        spi->dev.power.power_state = PMSG_ON; 
     862 
     863        spi->mode = SPI_MODE_0; 
     864        spi->bits_per_word = 8; 
     865        /* The max speed might've been defined by the board-specific 
     866         * struct */ 
     867        if (!spi->max_speed_hz) 
     868                spi->max_speed_hz = TSC2005_HZ; 
     869 
     870        spi_setup(spi); 
     871 
     872        r = tsc2005_ts_init(ts, pdata); 
     873        if (r) 
     874                goto err1; 
     875 
     876        return 0; 
     877 
     878err1: 
     879        kfree(ts); 
     880        return r; 
     881} 
     882 
     883static int __devexit tsc2005_remove(struct spi_device *spi) 
     884{ 
     885        struct tsc2005 *ts = dev_get_drvdata(&spi->dev); 
     886 
     887        mutex_lock(&ts->mutex); 
     888        tsc2005_disable(ts); 
     889        mutex_unlock(&ts->mutex); 
     890 
     891        device_remove_file(&ts->spi->dev, &dev_attr_disable_ts); 
     892        device_remove_file(&ts->spi->dev, &dev_attr_pen_down); 
     893        device_remove_file(&ts->spi->dev, &dev_attr_ts_ctrl_selftest); 
     894 
     895        free_irq(ts->spi->irq, ts); 
     896        input_unregister_device(ts->idev); 
     897 
     898        if (ts->esd_timeout) 
     899                del_timer(&ts->esd_timer); 
     900        kfree(ts); 
     901 
     902        return 0; 
     903} 
     904 
     905#ifdef CONFIG_PM 
     906static int tsc2005_suspend(struct spi_device *spi, pm_message_t mesg) 
     907{ 
     908        struct tsc2005 *ts = dev_get_drvdata(&spi->dev); 
     909 
     910        mutex_lock(&ts->mutex); 
     911        tsc2005_disable(ts); 
     912        mutex_unlock(&ts->mutex); 
     913 
     914        return 0; 
     915} 
     916 
     917static int tsc2005_resume(struct spi_device *spi) 
     918{ 
     919        struct tsc2005 *ts = dev_get_drvdata(&spi->dev); 
     920 
     921        mutex_lock(&ts->mutex); 
     922        tsc2005_enable(ts); 
     923        mutex_unlock(&ts->mutex); 
     924 
     925        return 0; 
     926} 
     927#endif 
     928 
     929static struct spi_driver tsc2005_driver = { 
     930        .driver = { 
     931                .name = "tsc2005", 
     932                .owner = THIS_MODULE, 
     933        }, 
     934#ifdef CONFIG_PM 
     935        .suspend = tsc2005_suspend, 
     936        .resume = tsc2005_resume, 
     937#endif 
     938        .probe = tsc2005_probe, 
     939        .remove = __devexit_p(tsc2005_remove), 
     940}; 
     941 
     942static int __init tsc2005_init(void) 
     943{ 
     944        printk(KERN_INFO "TSC2005 driver initializing\n"); 
     945 
     946        return spi_register_driver(&tsc2005_driver); 
     947} 
     948module_init(tsc2005_init); 
     949 
     950static void __exit tsc2005_exit(void) 
     951{ 
     952        spi_unregister_driver(&tsc2005_driver); 
     953} 
     954module_exit(tsc2005_exit); 
     955 
     956MODULE_AUTHOR("Lauri Leukkunen <lauri.leukkunen@nokia.com>"); 
     957MODULE_LICENSE("GPL"); 
     958MODULE_ALIAS("platform:tsc2005"); 
  • new file linux-2.6.38-rc6/include/linux/spi/tsc2005.h

    - +  
     1#ifndef _LINUX_SPI_TSC2005_H 
     2#define _LINUX_SPI_TSC2005_H 
     3 
     4#include <linux/types.h> 
     5 
     6struct tsc2005_platform_data { 
     7        u16     ts_x_plate_ohm; 
     8        u32     ts_stab_time;   /* voltage settling time */ 
     9        u8      ts_hw_avg;      /* HW assiseted averaging. Can be 
     10                                   0, 4, 8, 16 samples per reading */ 
     11        u32     ts_touch_pressure;      /* Pressure limit until we report a 
     12                                           touch event. After that we switch 
     13                                           to ts_max_pressure. */ 
     14        u32     ts_pressure_max;/* Samples with bigger pressure value will 
     15                                   be ignored, since the corresponding X, Y 
     16                                   values are unreliable */ 
     17        u32     ts_pressure_fudge; 
     18        u32     ts_x_max; 
     19        u32     ts_x_fudge; 
     20        u32     ts_y_max; 
     21        u32     ts_y_fudge; 
     22 
     23        u32     esd_timeout;    /* msec of inactivity before we check */ 
     24 
     25        unsigned ts_ignore_last:1; 
     26 
     27        void (*set_reset)(bool enable); 
     28}; 
     29 
     30#endif 
Note: See TracBrowser for help on using the repository browser.